diff --git a/res/values-ca/strings.xml b/res/values-ca/strings.xml
index a2eee73..2e2fac5 100644
--- a/res/values-ca/strings.xml
+++ b/res/values-ca/strings.xml
@@ -16,7 +16,7 @@
     <string name="google_apps_installer_name">Instal·lador Google Apps</string>
     <string name="google_apps_re_install_title">Google Apps instal·lat</string>
     <string name="wifi_disabled">Wi-Fi desconnectat</string>
-    <string name="wifi_discaimer_message">L\'arxiu que estàs intentant descarregar és massa gran si utilitzes una connexió mòbil (~200mb). Si us plau, connecta amb un punt Wi-Fi i prova de nou.</string>
+    <string name="wifi_discaimer_message">L\'arxiu que estàs intentant descarregar és massa gran si utilitzes una connexió mòbil. Si us plau, connecta amb un punt Wi-Fi i prova de nou.</string>
     <string name="gapps_store_install">Instal·lar Google Apps</string>
     <string name="gapps_store_hide_reminder">o tanca aquest recordatori</string>
     <string name="title_activity_beta_enabler">Fairphone programa beta</string>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index 63ca818..228d4c5 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -54,7 +54,7 @@
     <string name="want_to_change_your_os">Bist du ein fortgeschrittener Nutzer?</string>
     <string name="warning">Warnung</string>
     <string name="wifi_disabled">WLAN deaktiviert</string>
-    <string name="wifi_discaimer_message">Die Datei, die du herunterladen möchtest, ist zu groß für mobile Verbindungen (~200 MB). Bitte verbinde dich mit einem WLAN-Netzwerk und versuche es erneut.</string>
+    <string name="wifi_discaimer_message">Die Datei, die du herunterladen möchtest, ist zu groß für mobile Verbindungen. Bitte verbinde dich mit einem WLAN-Netzwerk und versuche es erneut.</string>
     <string name="your_are_about_to_install">Du bist dabei zu installieren</string>
     <string name="your_current_os_version">Dein aktuelles Betriebssystem</string>
     <string name="your_os_is_up_to_date">Dein Betriebssystem ist auf dem neusten Stand</string>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index 74b6fb5..2eae0fc 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -54,7 +54,7 @@
     <string name="want_to_change_your_os">¿Eres un usuario avanzado?</string>
     <string name="warning">Aviso</string>
     <string name="wifi_disabled">Wi-Fi desconectado</string>
-    <string name="wifi_discaimer_message">El archivo que estás intentando descargar es demasiado grande para conexiones móviles (~200mb). Por favor, conéctate a un punto Wi-Fi e inténtalo de nuevo.</string>
+    <string name="wifi_discaimer_message">El archivo que estás intentando descargar es demasiado grande para conexiones móviles. Por favor, conéctate a un punto Wi-Fi e inténtalo de nuevo.</string>
     <string name="your_are_about_to_install">Estás a punto de instalar</string>
     <string name="your_current_os_version">La versión actual de tu sistema operativo</string>
     <string name="your_os_is_up_to_date">Tu sistema operativo está actualizado.</string>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index 37ef0fa..28a0599 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -54,7 +54,7 @@
     <string name="want_to_change_your_os">Êtes-vous un utilisateur avancé ?</string>
     <string name="warning">Avertissement</string>
     <string name="wifi_disabled">Fonction Wi-Fi désactivée</string>
-    <string name="wifi_discaimer_message">Le fichier que vous tentez de télécharger est trop volumineux pour les connexions mobiles (~200 Mo). Connectez-vous au réseau Wi-Fi et réessayez.</string>
+    <string name="wifi_discaimer_message">Le fichier que vous tentez de télécharger est trop volumineux pour les connexions mobiles. Connectez-vous au réseau Wi-Fi et réessayez.</string>
     <string name="your_are_about_to_install">Vous êtes sur le point d\'installer</string>
     <string name="your_current_os_version">Version actuelle de votre système d\'exploitation actuel</string>
     <string name="your_os_is_up_to_date">Votre système d\'exploitation est à jour</string>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index 6279167..758834c 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -54,7 +54,7 @@
     <string name="want_to_change_your_os">Ben je een geavanceerde gebruiker?</string>
     <string name="warning">Waarschuwing</string>
     <string name="wifi_disabled">Wi-Fi niet beschikbaar</string>
-    <string name="wifi_discaimer_message">Het bestand dat je probeert te downloaden is te groot voor mobiele verbindingen (~200MB). Maak verbinding met een Wi-Fi netwerk en probeer het opnieuw.</string>
+    <string name="wifi_discaimer_message">Het bestand dat je probeert te downloaden is te groot voor mobiele verbindingen. Maak verbinding met een Wi-Fi netwerk en probeer het opnieuw.</string>
     <string name="your_are_about_to_install">Je staat op het punt te installeren</string>
     <string name="your_current_os_version">Je huidige versie van het besturingssysteem</string>
     <string name="your_os_is_up_to_date">Je besturingssysteem is up-to-date</string>
diff --git a/res/values-pt/strings.xml b/res/values-pt/strings.xml
index 092c32c..e3c2a69 100644
--- a/res/values-pt/strings.xml
+++ b/res/values-pt/strings.xml
@@ -54,7 +54,7 @@
     <string name="want_to_change_your_os">É um utilizador avançado?</string>
     <string name="warning">Aviso</string>
     <string name="wifi_disabled">Wi-Fi desligado</string>
-    <string name="wifi_discaimer_message">O ficheiro que está a tentar descarregar é muito grande para ligações móveis (~200mb). Por favor ligue-se ao Wi-Fi e tente outra vez.</string>
+    <string name="wifi_discaimer_message">O ficheiro que está a tentar descarregar é muito grande para ligações móveis. Por favor ligue-se ao Wi-Fi e tente outra vez.</string>
     <string name="your_are_about_to_install">Está prestes a instalar</string>
     <string name="your_current_os_version">Versão actual do Sistema Operativo</string>
     <string name="your_os_is_up_to_date">O Sistema Operativo está actualizado</string>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index ad8302d..1b13662 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -55,7 +55,7 @@
     <string name="want_to_change_your_os">Are you an advanced user?</string>
     <string name="warning">Warning</string>
     <string name="wifi_disabled">Wi-Fi disabled</string>
-    <string name="wifi_discaimer_message">The file you\'re trying to download is too large for mobile connections (~200MB). Please connect to a Wi-Fi network and try again.</string>
+    <string name="wifi_discaimer_message">The file you\'re trying to download is too large for mobile connections. Please connect to a Wi-Fi network and try again.</string>
     <string name="your_are_about_to_install">You are about to install</string>
     <string name="your_current_os_version">Your current operating system version</string>
     <string name="your_os_is_up_to_date">Your operating system is up-to-date</string>
