diff --git a/src/yunohost/app.py b/src/yunohost/app.py
index 296f21361..935b1ea6b 100644
--- a/src/yunohost/app.py
+++ b/src/yunohost/app.py
@@ -30,7 +30,6 @@ import yaml
 import time
 import re
 import urlparse
-import errno
 import subprocess
 import glob
 import pwd
@@ -39,7 +38,7 @@ from collections import OrderedDict
 from datetime import datetime
 
 from moulinette import msignals, m18n, msettings
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.filesystem import read_json
 
@@ -125,14 +124,12 @@ def app_fetchlist(url=None, name=None):
             appslists_to_be_fetched = [name]
             operation_logger.success()
         else:
-            raise MoulinetteError(errno.EINVAL,
-                                  m18n.n('custom_appslist_name_required'))
+            raise YunohostError('custom_appslist_name_required')
 
     # If a name is given, look for an appslist with that name and fetch it
     elif name is not None:
         if name not in appslists.keys():
-            raise MoulinetteError(errno.EINVAL,
-                                  m18n.n('appslist_unknown', appslist=name))
+            raise YunohostError('appslist_unknown', appslist=name)
         else:
             appslists_to_be_fetched = [name]
 
@@ -186,9 +183,7 @@ def app_fetchlist(url=None, name=None):
             with open(list_file, "w") as f:
                 f.write(appslist)
         except Exception as e:
-            raise MoulinetteError(errno.EIO,
-                                  "Error while writing appslist %s: %s" %
-                                  (name, str(e)))
+            raise YunohostError("Error while writing appslist %s: %s" % (name, str(e)), raw_msg=True)
 
         now = int(time.time())
         appslists[name]["lastUpdate"] = now
@@ -212,7 +207,7 @@ def app_removelist(operation_logger, name):
 
     # Make sure we know this appslist
     if name not in appslists.keys():
-        raise MoulinetteError(errno.ENOENT, m18n.n('appslist_unknown', appslist=name))
+        raise YunohostError('appslist_unknown', appslist=name)
 
     operation_logger.start()
 
@@ -343,8 +338,7 @@ def app_info(app, show_status=False, raw=False):
 
     """
     if not _is_installed(app):
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('app_not_installed', app=app))
+        raise YunohostError('app_not_installed', app=app)
 
     app_setting_path = APPS_SETTING_PATH + app
 
@@ -402,8 +396,7 @@ def app_map(app=None, raw=False, user=None):
 
     if app is not None:
         if not _is_installed(app):
-            raise MoulinetteError(errno.EINVAL,
-                                  m18n.n('app_not_installed', app=app))
+            raise YunohostError('app_not_installed', app=app)
         apps = [app, ]
     else:
         apps = os.listdir(APPS_SETTING_PATH)
@@ -455,11 +448,10 @@ def app_change_url(operation_logger, auth, app, domain, path):
 
     installed = _is_installed(app)
     if not installed:
-        raise MoulinetteError(errno.ENOPKG,
-                              m18n.n('app_not_installed', app=app))
+        raise YunohostError('app_not_installed', app=app)
 
     if not os.path.exists(os.path.join(APPS_SETTING_PATH, app, "scripts", "change_url")):
-        raise MoulinetteError(errno.EINVAL, m18n.n("app_change_no_change_url_script", app_name=app))
+        raise YunohostError("app_change_no_change_url_script", app_name=app)
 
     old_domain = app_setting(app, "domain")
     old_path = app_setting(app, "path")
@@ -471,7 +463,7 @@ def app_change_url(operation_logger, auth, app, domain, path):
     path = normalize_url_path(path)
 
     if (domain, path) == (old_domain, old_path):
-        raise MoulinetteError(errno.EINVAL, m18n.n("app_change_url_identical_domains", domain=domain, path=path))
+        raise YunohostError("app_change_url_identical_domains", domain=domain, path=path)
 
     # WARNING / FIXME : checkurl will modify the settings
     # (this is a non intuitive behavior that should be changed)
@@ -547,7 +539,7 @@ def app_change_url(operation_logger, auth, app, domain, path):
                                                stderr=subprocess.STDOUT,
                                                shell=True).rstrip()
 
-        raise MoulinetteError(errno.EINVAL, m18n.n("app_change_url_failed_nginx_reload", nginx_errors=nginx_errors))
+        raise YunohostError("app_change_url_failed_nginx_reload", nginx_errors=nginx_errors)
 
     logger.success(m18n.n("app_change_url_success",
                          app=app, domain=domain, path=path))
@@ -572,8 +564,8 @@ def app_upgrade(auth, app=[], url=None, file=None):
 
     try:
         app_list()
-    except MoulinetteError:
-        raise MoulinetteError(errno.ENODATA, m18n.n('app_no_upgrade'))
+    except YunohostError:
+        raise YunohostError('app_no_upgrade')
 
     upgraded_apps = []
 
@@ -593,8 +585,7 @@ def app_upgrade(auth, app=[], url=None, file=None):
         logger.info(m18n.n('app_upgrade_app_name', app=app_instance_name))
         installed = _is_installed(app_instance_name)
         if not installed:
-            raise MoulinetteError(errno.ENOPKG,
-                                  m18n.n('app_not_installed', app=app_instance_name))
+            raise YunohostError('app_not_installed', app=app_instance_name)
 
         if app_instance_name in upgraded_apps:
             continue
@@ -684,7 +675,7 @@ def app_upgrade(auth, app=[], url=None, file=None):
             operation_logger.success()
 
     if not upgraded_apps:
-        raise MoulinetteError(errno.ENODATA, m18n.n('app_no_upgrade'))
+        raise YunohostError('app_no_upgrade')
 
     app_ssowatconf(auth)
 
@@ -730,12 +721,12 @@ def app_install(operation_logger, auth, app, label=None, args=None, no_remove_on
     elif os.path.exists(app):
         manifest, extracted_app_folder = _extract_app_from_file(app)
     else:
-        raise MoulinetteError(errno.EINVAL, m18n.n('app_unknown'))
+        raise YunohostError('app_unknown')
     status['remote'] = manifest.get('remote', {})
 
     # Check ID
     if 'id' not in manifest or '__' in manifest['id']:
-        raise MoulinetteError(errno.EINVAL, m18n.n('app_id_invalid'))
+        raise YunohostError('app_id_invalid')
 
     app_id = manifest['id']
 
@@ -746,8 +737,7 @@ def app_install(operation_logger, auth, app, label=None, args=None, no_remove_on
     instance_number = _installed_instance_number(app_id, last=True) + 1
     if instance_number > 1:
         if 'multi_instance' not in manifest or not is_true(manifest['multi_instance']):
-            raise MoulinetteError(errno.EEXIST,
-                                  m18n.n('app_already_installed', app=app_id))
+            raise YunohostError('app_already_installed', app=app_id)
 
         # Change app_id to the forked app id
         app_instance_name = app_id + '__' + str(instance_number)
@@ -850,9 +840,9 @@ def app_install(operation_logger, auth, app, label=None, args=None, no_remove_on
 
             if install_retcode == -1:
                 msg = m18n.n('operation_interrupted') + " " + error_msg
-                raise MoulinetteError(errno.EINTR, msg)
+                raise YunohostError(msg, raw_msg=True)
             msg = error_msg
-            raise MoulinetteError(errno.EIO, msg)
+            raise YunohostError(msg, raw_msg=True)
 
     # Clean hooks and add new ones
     hook_remove(app_instance_name)
@@ -888,8 +878,7 @@ def app_remove(operation_logger, auth, app):
     """
     from yunohost.hook import hook_exec, hook_remove, hook_callback
     if not _is_installed(app):
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('app_not_installed', app=app))
+        raise YunohostError('app_not_installed', app=app)
 
     operation_logger.start()
 
@@ -979,7 +968,7 @@ def app_addaccess(auth, apps, users=[]):
                 if allowed_user not in allowed_users:
                     try:
                         user_info(auth, allowed_user)
-                    except MoulinetteError:
+                    except YunohostError:
                         logger.warning(m18n.n('user_unknown', user=allowed_user))
                         continue
                     allowed_users.add(allowed_user)
@@ -1139,21 +1128,17 @@ def app_makedefault(operation_logger, auth, app, domain=None):
         domain = app_domain
         operation_logger.related_to.append(('domain',domain))
     elif domain not in domain_list(auth)['domains']:
-        raise MoulinetteError(errno.EINVAL, m18n.n('domain_unknown'))
+        raise YunohostError('domain_unknown')
 
     operation_logger.start()
     if '/' in app_map(raw=True)[domain]:
-        raise MoulinetteError(errno.EEXIST,
-                              m18n.n('app_make_default_location_already_used',
-                                     app=app, domain=app_domain,
-                                     other_app=app_map(raw=True)[domain]["/"]["id"]))
+        raise YunohostError('app_make_default_location_already_used', app=app, domain=app_domain, other_app=app_map(raw=True)[domain]["/"]["id"])
 
     try:
         with open('/etc/ssowat/conf.json.persistent') as json_conf:
             ssowat_conf = json.loads(str(json_conf.read()))
     except ValueError as e:
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('ssowat_persistent_conf_read_error', error=e.strerror))
+        raise YunohostError('ssowat_persistent_conf_read_error', error=e.strerror)
     except IOError:
         ssowat_conf = {}
 
@@ -1166,8 +1151,7 @@ def app_makedefault(operation_logger, auth, app, domain=None):
         with open('/etc/ssowat/conf.json.persistent', 'w+') as f:
             json.dump(ssowat_conf, f, sort_keys=True, indent=4)
     except IOError as e:
-        raise MoulinetteError(errno.EPERM,
-                              m18n.n('ssowat_persistent_conf_write_error', error=e.strerror))
+        raise YunohostError('ssowat_persistent_conf_write_error', error=e.strerror)
 
     os.system('chmod 644 /etc/ssowat/conf.json.persistent')
 
@@ -1219,8 +1203,7 @@ def app_checkport(port):
     if tools_port_available(port):
         logger.success(m18n.n('port_available', port=int(port)))
     else:
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('port_unavailable', port=int(port)))
+        raise YunohostError('port_unavailable', port=int(port))
 
 
 def app_register_url(auth, app, domain, path):
@@ -1247,8 +1230,7 @@ def app_register_url(auth, app, domain, path):
     if installed:
         settings = _get_app_settings(app)
         if "path" in settings.keys() and "domain" in settings.keys():
-            raise MoulinetteError(errno.EINVAL,
-                                  m18n.n('app_already_installed_cant_change_url'))
+            raise YunohostError('app_already_installed_cant_change_url')
 
     # Check the url is available
     conflicts = _get_conflicting_apps(auth, domain, path)
@@ -1262,7 +1244,7 @@ def app_register_url(auth, app, domain, path):
                 app_label=app_label,
             ))
 
-        raise MoulinetteError(errno.EINVAL, m18n.n('app_location_unavailable', apps="\n".join(apps)))
+        raise YunohostError('app_location_unavailable', apps="\n".join(apps))
 
     app_setting(app, 'domain', value=domain)
     app_setting(app, 'path', value=path)
@@ -1300,7 +1282,7 @@ def app_checkurl(auth, url, app=None):
     apps_map = app_map(raw=True)
 
     if domain not in domain_list(auth)['domains']:
-        raise MoulinetteError(errno.EINVAL, m18n.n('domain_unknown'))
+        raise YunohostError('domain_unknown')
 
     if domain in apps_map:
         # Loop through apps
@@ -1310,14 +1292,10 @@ def app_checkurl(auth, url, app=None):
                 installed = True
                 continue
             if path == p:
-                raise MoulinetteError(errno.EINVAL,
-                                      m18n.n('app_location_already_used',
-                                             app=a["id"], path=path))
+                raise YunohostError('app_location_already_used', app=a["id"], path=path)
             # can't install "/a/b/" if "/a/" exists
             elif path.startswith(p) or p.startswith(path):
-                raise MoulinetteError(errno.EPERM,
-                                      m18n.n('app_location_install_failed',
-                                             other_path=p, other_app=a['id']))
+                raise YunohostError('app_location_install_failed', other_path=p, other_app=a['id'])
 
     if app is not None and not installed:
         app_setting(app, 'domain', value=domain)
@@ -1349,10 +1327,10 @@ def app_initdb(user, password=None, db=None, sql=None):
     mysql_root_pwd = open('/etc/yunohost/mysql').read().rstrip()
     mysql_command = 'mysql -u root -p%s -e "CREATE DATABASE %s ; GRANT ALL PRIVILEGES ON %s.* TO \'%s\'@localhost IDENTIFIED BY \'%s\';"' % (mysql_root_pwd, db, db, user, password)
     if os.system(mysql_command) != 0:
-        raise MoulinetteError(errno.EIO, m18n.n('mysql_db_creation_failed'))
+        raise YunohostError('mysql_db_creation_failed')
     if sql is not None:
         if os.system('mysql -u %s -p%s %s < %s' % (user, password, db, sql)) != 0:
-            raise MoulinetteError(errno.EIO, m18n.n('mysql_db_init_failed'))
+            raise YunohostError('mysql_db_init_failed')
 
     if return_pwd:
         return password
@@ -1458,8 +1436,7 @@ def app_ssowatconf(auth):
 def app_change_label(auth, app, new_label):
     installed = _is_installed(app)
     if not installed:
-        raise MoulinetteError(errno.ENOPKG,
-                              m18n.n('app_not_installed', app=app))
+        raise YunohostError('app_not_installed', app=app)
 
     app_setting(app, "label", value=new_label)
 
@@ -1495,7 +1472,7 @@ def app_action_run(app, action, args=None):
     actions = {x["id"]: x for x in actions}
 
     if action not in actions:
-        raise MoulinetteError(errno.EINVAL, "action '%s' not available for app '%s', available actions are: %s" % (action, app, ", ".join(actions.keys())))
+        raise YunohostError("action '%s' not available for app '%s', available actions are: %s" % (action, app, ", ".join(actions.keys())), raw_msg=True)
 
     action_declaration = actions[action]
 
@@ -1533,7 +1510,7 @@ def app_action_run(app, action, args=None):
     )
 
     if retcode not in action_declaration.get("accepted_return_codes", [0]):
-        raise MoulinetteError(retcode, "Error while executing action '%s' of app '%s': return code %s" % (action, app, retcode))
+        raise YunohostError("Error while executing action '%s' of app '%s': return code %s" % (action, app, retcode), raw_msg=True)
 
     os.remove(path)
 
@@ -1640,8 +1617,7 @@ def app_config_apply(app, args):
 
     installed = _is_installed(app)
     if not installed:
-        raise MoulinetteError(errno.ENOPKG,
-                              m18n.n('app_not_installed', app=app))
+        raise YunohostError('app_not_installed', app=app)
 
     config_panel = os.path.join(APPS_SETTING_PATH, app, 'config_panel.json')
     config_script = os.path.join(APPS_SETTING_PATH, app, 'scripts', 'config')
@@ -1699,8 +1675,7 @@ def _get_app_settings(app_id):
 
     """
     if not _is_installed(app_id):
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('app_not_installed', app=app_id))
+        raise YunohostError('app_not_installed', app=app_id)
     try:
         with open(os.path.join(
                 APPS_SETTING_PATH, app_id, 'settings.yml')) as f:
@@ -1738,7 +1713,7 @@ def _get_app_status(app_id, format_date=False):
     """
     app_setting_path = APPS_SETTING_PATH + app_id
     if not os.path.isdir(app_setting_path):
-        raise MoulinetteError(errno.EINVAL, m18n.n('app_unknown'))
+        raise YunohostError('app_unknown')
     status = {}
 
     try:
@@ -1803,7 +1778,7 @@ def _extract_app_from_file(path, remove=False):
         extract_result = 1
 
     if extract_result != 0:
-        raise MoulinetteError(errno.EINVAL, m18n.n('app_extraction_failed'))
+        raise YunohostError('app_extraction_failed')
 
     try:
         extracted_app_folder = APP_TMP_FOLDER
@@ -1814,10 +1789,9 @@ def _extract_app_from_file(path, remove=False):
             manifest = json.loads(str(json_manifest.read()))
             manifest['lastUpdate'] = int(time.time())
     except IOError:
-        raise MoulinetteError(errno.EIO, m18n.n('app_install_files_invalid'))
+        raise YunohostError('app_install_files_invalid')
     except ValueError as e:
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('app_manifest_invalid', error=e.strerror))
+        raise YunohostError('app_manifest_invalid', error=e.strerror)
 
     logger.debug(m18n.n('done'))
 
@@ -1885,8 +1859,7 @@ def _fetch_app_from_git(app):
                     'wget', '-qO', app_tmp_archive, tarball_url])
             except subprocess.CalledProcessError:
                 logger.exception('unable to download %s', tarball_url)
-                raise MoulinetteError(errno.EIO,
-                                      m18n.n('app_sources_fetch_failed'))
+                raise YunohostError('app_sources_fetch_failed')
             else:
                 manifest, extracted_app_folder = _extract_app_from_file(
                     app_tmp_archive, remove=True)
@@ -1909,11 +1882,9 @@ def _fetch_app_from_git(app):
                 with open(extracted_app_folder + '/manifest.json') as f:
                     manifest = json.loads(str(f.read()))
             except subprocess.CalledProcessError:
-                raise MoulinetteError(errno.EIO,
-                                      m18n.n('app_sources_fetch_failed'))
+                raise YunohostError('app_sources_fetch_failed')
             except ValueError as e:
-                raise MoulinetteError(errno.EIO,
-                                      m18n.n('app_manifest_invalid', error=e.strerror))
+                raise YunohostError('app_manifest_invalid', error=e.strerror)
             else:
                 logger.debug(m18n.n('done'))
 
@@ -1933,11 +1904,10 @@ def _fetch_app_from_git(app):
             app_info['manifest']['lastUpdate'] = app_info['lastUpdate']
             manifest = app_info['manifest']
         else:
-            raise MoulinetteError(errno.EINVAL, m18n.n('app_unknown'))
+            raise YunohostError('app_unknown')
 
         if 'git' not in app_info:
-            raise MoulinetteError(errno.EINVAL,
-                                  m18n.n('app_unsupported_remote_type'))
+            raise YunohostError('app_unsupported_remote_type')
         url = app_info['git']['url']
 
         if 'github.com' in url:
@@ -1949,8 +1919,7 @@ def _fetch_app_from_git(app):
                     'wget', '-qO', app_tmp_archive, tarball_url])
             except subprocess.CalledProcessError:
                 logger.exception('unable to download %s', tarball_url)
-                raise MoulinetteError(errno.EIO,
-                                      m18n.n('app_sources_fetch_failed'))
+                raise YunohostError('app_sources_fetch_failed')
             else:
                 manifest, extracted_app_folder = _extract_app_from_file(
                     app_tmp_archive, remove=True)
@@ -1966,11 +1935,9 @@ def _fetch_app_from_git(app):
                 with open(extracted_app_folder + '/manifest.json') as f:
                     manifest = json.loads(str(f.read()))
             except subprocess.CalledProcessError:
-                raise MoulinetteError(errno.EIO,
-                                      m18n.n('app_sources_fetch_failed'))
+                raise YunohostError('app_sources_fetch_failed')
             except ValueError as e:
-                raise MoulinetteError(errno.EIO,
-                                      m18n.n('app_manifest_invalid', error=e.strerror))
+                raise YunohostError('app_manifest_invalid', error=e.strerror)
             else:
                 logger.debug(m18n.n('done'))
 
@@ -2089,7 +2056,7 @@ def _check_manifest_requirements(manifest, app_instance_name):
         yunohost_req = requirements.get('yunohost', None)
         if (not yunohost_req or
                 not packages.SpecifierSet(yunohost_req) & '>= 2.3.6'):
-            raise MoulinetteError(errno.EINVAL, '{0}{1}'.format(
+            raise YunohostError('{0}{1}'.format(
                 m18n.g('colon', m18n.n('app_incompatible'), app=app_instance_name),
                 m18n.n('app_package_need_update', app=app_instance_name)))
     elif not requirements:
@@ -2102,18 +2069,15 @@ def _check_manifest_requirements(manifest, app_instance_name):
         versions = packages.get_installed_version(
             *requirements.keys(), strict=True, as_dict=True)
     except packages.PackageException as e:
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('app_requirements_failed',
-                                     error=str(e), app=app_instance_name))
+        raise YunohostError('app_requirements_failed', error=str(e), app=app_instance_name)
 
     # Iterate over requirements
     for pkgname, spec in requirements.items():
         version = versions[pkgname]
         if version not in packages.SpecifierSet(spec):
-            raise MoulinetteError(
-                errno.EINVAL, m18n.n('app_requirements_unmeet',
-                                     pkgname=pkgname, version=version,
-                                     spec=spec, app=app_instance_name))
+            raise YunohostError('app_requirements_unmeet',
+                                pkgname=pkgname, version=version,
+                                spec=spec, app=app_instance_name)
 
 
 def _parse_args_from_manifest(manifest, action, args={}, auth=None):
@@ -2237,36 +2201,27 @@ def _parse_action_args_in_yunohost_format(args, action_args, auth=None):
         # Validate argument value
         if (arg_value is None or arg_value == '') \
                 and not arg.get('optional', False):
-            raise MoulinetteError(errno.EINVAL,
-                m18n.n('app_argument_required', name=arg_name))
+            raise YunohostError('app_argument_required', name=arg_name)
         elif arg_value is None:
             args_dict[arg_name] = ''
             continue
 
         # Validate argument choice
         if arg_choices and arg_value not in arg_choices:
-            raise MoulinetteError(errno.EINVAL,
-                m18n.n('app_argument_choice_invalid',
-                    name=arg_name, choices=', '.join(arg_choices)))
+            raise YunohostError('app_argument_choice_invalid', name=arg_name, choices=', '.join(arg_choices))
 
         # Validate argument type
         if arg_type == 'domain':
             if arg_value not in domain_list(auth)['domains']:
-                raise MoulinetteError(errno.EINVAL,
-                    m18n.n('app_argument_invalid',
-                        name=arg_name, error=m18n.n('domain_unknown')))
+                raise YunohostError('app_argument_invalid', name=arg_name, error=m18n.n('domain_unknown'))
         elif arg_type == 'user':
             try:
                 user_info(auth, arg_value)
-            except MoulinetteError as e:
-                raise MoulinetteError(errno.EINVAL,
-                    m18n.n('app_argument_invalid',
-                        name=arg_name, error=e.strerror))
+            except YunohostError as e:
+                raise YunohostError('app_argument_invalid', name=arg_name, error=e.strerror)
         elif arg_type == 'app':
             if not _is_installed(arg_value):
-                raise MoulinetteError(errno.EINVAL,
-                    m18n.n('app_argument_invalid',
-                        name=arg_name, error=m18n.n('app_unknown')))
+                raise YunohostError('app_argument_invalid', name=arg_name, error=m18n.n('app_unknown'))
         elif arg_type == 'boolean':
             if isinstance(arg_value, bool):
                 arg_value = 1 if arg_value else 0
@@ -2276,9 +2231,7 @@ def _parse_action_args_in_yunohost_format(args, action_args, auth=None):
                 elif str(arg_value).lower() in ["0", "no", "n"]:
                     arg_value = 0
                 else:
-                    raise MoulinetteError(errno.EINVAL,
-                        m18n.n('app_argument_choice_invalid',
-                            name=arg_name, choices='yes, no, y, n, 1, 0'))
+                    raise YunohostError('app_argument_choice_invalid', name=arg_name, choices='yes, no, y, n, 1, 0')
         elif arg_type == 'password':
             from yunohost.utils.password import assert_password_is_strong_enough
             assert_password_is_strong_enough('user', arg_value)
@@ -2312,7 +2265,7 @@ def _parse_action_args_in_yunohost_format(args, action_args, auth=None):
                     app_label=app_label,
                 ))
 
-            raise MoulinetteError(errno.EINVAL, m18n.n('app_location_unavailable', apps="\n".join(apps)))
+            raise YunohostError('app_location_unavailable', apps="\n".join(apps))
 
         # (We save this normalized path so that the install script have a
         # standard path format to deal with no matter what the user inputted)
@@ -2462,8 +2415,7 @@ def _read_appslist_list():
     try:
         appslists = json.loads(appslists_json)
     except ValueError:
-        raise MoulinetteError(errno.EBADR,
-                              m18n.n('appslist_corrupted_json', filename=APPSLISTS_JSON))
+        raise YunohostError('appslist_corrupted_json', filename=APPSLISTS_JSON)
 
     return appslists
 
@@ -2478,9 +2430,8 @@ def _write_appslist_list(appslist_lists):
         with open(APPSLISTS_JSON, "w") as f:
             json.dump(appslist_lists, f)
     except Exception as e:
-        raise MoulinetteError(errno.EIO,
-                              "Error while writing list of appslist %s: %s" %
-                              (APPSLISTS_JSON, str(e)))
+        raise YunohostError("Error while writing list of appslist %s: %s" %
+                              (APPSLISTS_JSON, str(e)), raw_msg=True)
 
 
 def _register_new_appslist(url, name):
@@ -2493,15 +2444,13 @@ def _register_new_appslist(url, name):
 
     # Check if name conflicts with an existing list
     if name in appslist_list:
-        raise MoulinetteError(errno.EEXIST,
-                              m18n.n('appslist_name_already_tracked', name=name))
+        raise YunohostError('appslist_name_already_tracked', name=name)
 
     # Check if url conflicts with an existing list
     known_appslist_urls = [appslist["url"] for _, appslist in appslist_list.items()]
 
     if url in known_appslist_urls:
-        raise MoulinetteError(errno.EEXIST,
-                              m18n.n('appslist_url_already_tracked', url=url))
+        raise YunohostError('appslist_url_already_tracked', url=url)
 
     logger.debug("Registering new appslist %s at %s" % (name, url))
 
diff --git a/src/yunohost/backup.py b/src/yunohost/backup.py
index 33fbccb7f..6ed73d343 100644
--- a/src/yunohost/backup.py
+++ b/src/yunohost/backup.py
@@ -26,7 +26,6 @@
 import os
 import re
 import json
-import errno
 import time
 import tarfile
 import shutil
@@ -38,7 +37,7 @@ from glob import glob
 from collections import OrderedDict
 
 from moulinette import msignals, m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils import filesystem
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.filesystem import read_file
@@ -308,14 +307,14 @@ class BackupManager():
         Ensure the working directory exists and is empty
 
         exception:
-        backup_output_directory_not_empty -- (MoulinetteError) Raised if the
+        backup_output_directory_not_empty -- (YunohostError) Raised if the
             directory was given by the user and isn't empty
 
-        (TODO) backup_cant_clean_tmp_working_directory -- (MoulinetteError)
+        (TODO) backup_cant_clean_tmp_working_directory -- (YunohostError)
             Raised if the working directory isn't empty, is temporary and can't
             be automaticcaly cleaned
 
-        (TODO) backup_cant_create_working_directory -- (MoulinetteError) Raised
+        (TODO) backup_cant_create_working_directory -- (YunohostError) Raised
             if iyunohost can't create the working directory
         """
 
@@ -327,8 +326,7 @@ class BackupManager():
             logger.debug("temporary directory for backup '%s' already exists",
                          self.work_dir)
             # FIXME May be we should clean the workdir here
-            raise MoulinetteError(
-                errno.EIO, m18n.n('backup_output_directory_not_empty'))
+            raise YunohostError('backup_output_directory_not_empty')
 
     ###########################################################################
     #   Backup target management                                              #
@@ -494,7 +492,7 @@ class BackupManager():
                       copied here
 
         Exceptions:
-        "backup_nothings_done" -- (MoulinetteError) This exception is raised if
+        "backup_nothings_done" -- (YunohostError) This exception is raised if
         nothing has been listed.
         """
 
@@ -507,7 +505,7 @@ class BackupManager():
 
         if not successfull_apps and not successfull_system:
             filesystem.rm(self.work_dir, True, True)
-            raise MoulinetteError(errno.EINVAL, m18n.n('backup_nothings_done'))
+            raise YunohostError('backup_nothings_done')
 
         # Add unlisted files from backup tmp dir
         self._add_to_list_to_backup('backup.csv')
@@ -857,7 +855,7 @@ class RestoreManager():
                 self.info["system"] = self.info["hooks"]
         except IOError:
             logger.debug("unable to load '%s'", info_file, exc_info=1)
-            raise MoulinetteError(errno.EIO, m18n.n('backup_invalid_archive'))
+            raise YunohostError('backup_invalid_archive')
         else:
             logger.debug("restoring from backup '%s' created on %s", self.name,
                          datetime.utcfromtimestamp(self.info['created_at']))
@@ -880,8 +878,7 @@ class RestoreManager():
                 logger.debug("unable to retrieve current_host from the backup",
                             exc_info=1)
                 # FIXME include the current_host by default ?
-                raise MoulinetteError(errno.EIO,
-                                    m18n.n('backup_invalid_archive'))
+                raise YunohostError('backup_invalid_archive')
 
             logger.debug("executing the post-install...")
             tools_postinstall(domain, 'yunohost', True)
@@ -1010,8 +1007,7 @@ class RestoreManager():
                 subprocess.call(['rmdir', self.work_dir])
                 logger.debug("Unmount dir: {}".format(self.work_dir))
             else:
-                raise MoulinetteError(errno.EIO,
-                                      m18n.n('restore_removing_tmp_dir_failed'))
+                raise YunohostError('restore_removing_tmp_dir_failed')
         elif os.path.isdir(self.work_dir):
             logger.debug("temporary restore directory '%s' already exists",
                          self.work_dir)
@@ -1019,8 +1015,7 @@ class RestoreManager():
             if ret == 0:
                 logger.debug("Delete dir: {}".format(self.work_dir))
             else:
-                raise MoulinetteError(errno.EIO,
-                                      m18n.n('restore_removing_tmp_dir_failed'))
+                raise YunohostError('restore_removing_tmp_dir_failed')
 
         filesystem.mkdir(self.work_dir, parents=True)
 
@@ -1087,17 +1082,9 @@ class RestoreManager():
             return True
         elif free_space > needed_space:
             # TODO Add --force options to avoid the error raising
-            raise MoulinetteError(errno.EIO,
-                                  m18n.n('restore_may_be_not_enough_disk_space',
-                                  free_space=free_space,
-                                  needed_space=needed_space,
-                                  margin=margin))
+            raise YunohostError('restore_may_be_not_enough_disk_space', free_space=free_space,  needed_space=needed_space, margin=margin)
         else:
-            raise MoulinetteError(errno.EIO,
-                                  m18n.n('restore_not_enough_disk_space',
-                                  free_space=free_space,
-                                  needed_space=needed_space,
-                                  margin=margin))
+            raise YunohostError('restore_not_enough_disk_space', free_space=free_space, needed_space=needed_space, margin=margin)
 
     ###########################################################################
     #   "Actual restore" (reverse step of the backup collect part)            #
@@ -1147,9 +1134,7 @@ class RestoreManager():
 
                     newlines.append(row)
         except (IOError, OSError, csv.Error) as e:
-            raise MoulinetteError(errno.EIO,m18n.n('error_reading_file',
-                                                   file=backup_csv,
-                                                   error=str(e)))
+            raise YunohostError('error_reading_file', file=backup_csv, error=str(e))
 
         if not contains_php5:
             return
@@ -1442,7 +1427,7 @@ class BackupMethod(object):
     @property
     def method_name(self):
         """Return the string name of a BackupMethod (eg "tar" or "copy")"""
-        raise MoulinetteError(errno.EINVAL, m18n.n('backup_abstract_method'))
+        raise YunohostError('backup_abstract_method')
 
     @property
     def name(self):
@@ -1524,8 +1509,7 @@ class BackupMethod(object):
         """
         if self.need_mount():
             if self._recursive_umount(self.work_dir) > 0:
-                raise MoulinetteError(errno.EINVAL,
-                                      m18n.n('backup_cleaning_failed'))
+                raise YunohostError('backup_cleaning_failed')
 
         if self.manager.is_tmp_work_dir:
             filesystem.rm(self.work_dir, True, True)
@@ -1567,8 +1551,7 @@ class BackupMethod(object):
         if free_space < backup_size:
             logger.debug('Not enough space at %s (free: %s / needed: %d)',
                          self.repo, free_space, backup_size)
-            raise MoulinetteError(errno.EIO, m18n.n(
-                'not_enough_disk_space', path=self.repo))
+            raise YunohostError('not_enough_disk_space', path=self.repo)
 
     def _organize_files(self):
         """
@@ -1656,12 +1639,10 @@ class BackupMethod(object):
                 i = msignals.prompt(m18n.n('backup_ask_for_copying_if_needed',
                                         answers='y/N', size=str(size)))
             except NotImplemented:
-                raise MoulinetteError(errno.EIO,
-                                     m18n.n('backup_unable_to_organize_files'))
+                raise YunohostError('backup_unable_to_organize_files')
             else:
                 if i != 'y' and i != 'Y':
-                    raise MoulinetteError(errno.EIO,
-                                     m18n.n('backup_unable_to_organize_files'))
+                    raise YunohostError('backup_unable_to_organize_files')
 
         # Copy unbinded path
         logger.debug(m18n.n('backup_copying_to_organize_the_archive',
@@ -1751,8 +1732,7 @@ class CopyBackupMethod(BackupMethod):
         super(CopyBackupMethod, self).mount()
 
         if not os.path.isdir(self.repo):
-            raise MoulinetteError(errno.EIO,
-                                  m18n.n('backup_no_uncompress_archive_dir'))
+            raise YunohostError('backup_no_uncompress_archive_dir')
 
         filesystem.mkdir(self.work_dir, parent=True)
         ret = subprocess.call(["mount", "-r", "--rbind", self.repo,
@@ -1763,8 +1743,7 @@ class CopyBackupMethod(BackupMethod):
             logger.warning(m18n.n("bind_mouting_disable"))
             subprocess.call(["mountpoint", "-q", dest,
                             "&&", "umount", "-R", dest])
-            raise MoulinetteError(errno.EIO,
-                                  m18n.n('backup_cant_mount_uncompress_archive'))
+            raise YunohostError('backup_cant_mount_uncompress_archive')
 
 
 class TarBackupMethod(BackupMethod):
@@ -1809,8 +1788,7 @@ class TarBackupMethod(BackupMethod):
         except:
             logger.debug("unable to open '%s' for writing",
                          self._archive_file, exc_info=1)
-            raise MoulinetteError(errno.EIO,
-                                  m18n.n('backup_archive_open_failed'))
+            raise YunohostError('backup_archive_open_failed')
 
         # Add files to the archive
         try:
@@ -1821,8 +1799,7 @@ class TarBackupMethod(BackupMethod):
             tar.close()
         except IOError:
             logger.error(m18n.n('backup_archive_writing_error'), exc_info=1)
-            raise MoulinetteError(errno.EIO,
-                                  m18n.n('backup_creation_failed'))
+            raise YunohostError('backup_creation_failed')
 
         # Move info file
         shutil.copy(os.path.join(self.work_dir, 'info.json'),
@@ -1850,8 +1827,7 @@ class TarBackupMethod(BackupMethod):
         except:
             logger.debug("cannot open backup archive '%s'",
                          self._archive_file, exc_info=1)
-            raise MoulinetteError(errno.EIO,
-                                  m18n.n('backup_archive_open_failed'))
+            raise YunohostError('backup_archive_open_failed')
         tar.close()
 
         # Mount the tarball
@@ -1912,12 +1888,10 @@ class BorgBackupMethod(BackupMethod):
         super(CopyBackupMethod, self).backup()
 
         # TODO run borg create command
-        raise MoulinetteError(
-            errno.EIO, m18n.n('backup_borg_not_implemented'))
+        raise YunohostError('backup_borg_not_implemented')
 
     def mount(self, mnt_path):
-        raise MoulinetteError(
-            errno.EIO, m18n.n('backup_borg_not_implemented'))
+        raise YunohostError('backup_borg_not_implemented')
 
 
 class CustomBackupMethod(BackupMethod):
@@ -1963,8 +1937,7 @@ class CustomBackupMethod(BackupMethod):
         ret = hook_callback('backup_method', [self.method],
                             args=self._get_args('backup'))
         if ret['failed']:
-            raise MoulinetteError(errno.EIO,
-                                  m18n.n('backup_custom_backup_error'))
+            raise YunohostError('backup_custom_backup_error')
 
     def mount(self, restore_manager):
         """
@@ -1977,8 +1950,7 @@ class CustomBackupMethod(BackupMethod):
         ret = hook_callback('backup_method', [self.method],
                             args=self._get_args('mount'))
         if ret['failed']:
-            raise MoulinetteError(errno.EIO,
-                                  m18n.n('backup_custom_mount_error'))
+            raise YunohostError('backup_custom_mount_error')
 
     def _get_args(self, action):
         """Return the arguments to give to the custom script"""
@@ -2014,8 +1986,7 @@ def backup_create(name=None, description=None, methods=[],
 
     # Validate there is no archive with the same name
     if name and name in backup_list()['archives']:
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('backup_archive_name_exists'))
+        raise YunohostError('backup_archive_name_exists')
 
     # Validate output_directory option
     if output_directory:
@@ -2025,17 +1996,14 @@ def backup_create(name=None, description=None, methods=[],
         if output_directory.startswith(ARCHIVES_PATH) or \
             re.match(r'^/(|(bin|boot|dev|etc|lib|root|run|sbin|sys|usr|var)(|/.*))$',
                  output_directory):
-            raise MoulinetteError(errno.EINVAL,
-                                  m18n.n('backup_output_directory_forbidden'))
+            raise YunohostError('backup_output_directory_forbidden')
 
         # Check that output directory is empty
         if os.path.isdir(output_directory) and no_compress and \
                 os.listdir(output_directory):
-            raise MoulinetteError(errno.EIO,
-                                  m18n.n('backup_output_directory_not_empty'))
+            raise YunohostError('backup_output_directory_not_empty')
     elif no_compress:
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('backup_output_directory_required'))
+        raise YunohostError('backup_output_directory_required')
 
     # Define methods (retro-compat)
     if not methods:
@@ -2132,7 +2100,7 @@ def backup_restore(auth, name, system=[], apps=[], force=False):
                 if i == 'y' or i == 'Y':
                     force = True
             if not force:
-                raise MoulinetteError(errno.EEXIST, m18n.n('restore_failed'))
+                raise YunohostError('restore_failed')
 
     # TODO Partial app restore could not work if ldap is not restored before
     # TODO repair mysql if broken and it's a complete restore
@@ -2159,7 +2127,7 @@ def backup_restore(auth, name, system=[], apps=[], force=False):
     if restore_manager.success:
         logger.success(m18n.n('restore_complete'))
     else:
-        raise MoulinetteError(errno.EINVAL, m18n.n('restore_nothings_done'))
+        raise YunohostError('restore_nothings_done')
 
     return restore_manager.targets.results
 
@@ -2195,7 +2163,7 @@ def backup_list(with_info=False, human_readable=False):
         for a in result:
             try:
                 d[a] = backup_info(a, human_readable=human_readable)
-            except MoulinetteError, e:
+            except YunohostError as e:
                 logger.warning('%s: %s' % (a, e.strerror))
 
         result = d
@@ -2217,8 +2185,7 @@ def backup_info(name, with_details=False, human_readable=False):
 
     # Check file exist (even if it's a broken symlink)
     if not os.path.lexists(archive_file):
-        raise MoulinetteError(errno.EIO,
-                              m18n.n('backup_archive_name_unknown', name=name))
+        raise YunohostError('backup_archive_name_unknown', name=name)
 
     # If symlink, retrieve the real path
     if os.path.islink(archive_file):
@@ -2226,9 +2193,8 @@ def backup_info(name, with_details=False, human_readable=False):
 
         # Raise exception if link is broken (e.g. on unmounted external storage)
         if not os.path.exists(archive_file):
-            raise MoulinetteError(errno.EIO,
-                                  m18n.n('backup_archive_broken_link',
-                                         path=archive_file))
+            raise YunohostError('backup_archive_broken_link',
+                                         path=archive_file)
 
     info_file = "%s/%s.info.json" % (ARCHIVES_PATH, name)
 
@@ -2240,7 +2206,7 @@ def backup_info(name, with_details=False, human_readable=False):
         except KeyError:
             logger.debug("unable to retrieve '%s' inside the archive",
                          info_file, exc_info=1)
-            raise MoulinetteError(errno.EIO, m18n.n('backup_invalid_archive'))
+            raise YunohostError('backup_invalid_archive')
         else:
             shutil.move(os.path.join(info_dir, 'info.json'), info_file)
         finally:
@@ -2253,7 +2219,7 @@ def backup_info(name, with_details=False, human_readable=False):
             info = json.load(f)
     except:
         logger.debug("unable to load '%s'", info_file, exc_info=1)
-        raise MoulinetteError(errno.EIO, m18n.n('backup_invalid_archive'))
+        raise YunohostError('backup_invalid_archive')
 
     # Retrieve backup size
     size = info.get('size', 0)
@@ -2292,8 +2258,8 @@ def backup_delete(name):
 
     """
     if name not in backup_list()["archives"]:
-        raise MoulinetteError(errno.EIO, m18n.n('backup_archive_name_unknown',
-                                                name=name))
+        raise YunohostError('backup_archive_name_unknown',
+                                                name=name)
 
     hook_callback('pre_backup_delete', args=[name])
 
@@ -2320,9 +2286,7 @@ def _create_archive_dir():
     """ Create the YunoHost archives directory if doesn't exist """
     if not os.path.isdir(ARCHIVES_PATH):
         if os.path.lexists(ARCHIVES_PATH):
-            raise MoulinetteError(errno.EINVAL,
-                                  m18n.n('backup_output_symlink_dir_broken',
-                                         path=ARCHIVES_PATH))
+            raise YunohostError('backup_output_symlink_dir_broken', path=ARCHIVES_PATH)
 
         os.mkdir(ARCHIVES_PATH, 0750)
 
diff --git a/src/yunohost/certificate.py b/src/yunohost/certificate.py
index 5c3bf8c9e..cdcf4bbe9 100644
--- a/src/yunohost/certificate.py
+++ b/src/yunohost/certificate.py
@@ -24,7 +24,6 @@
 
 import os
 import sys
-import errno
 import shutil
 import pwd
 import grp
@@ -37,7 +36,7 @@ from datetime import datetime
 
 from yunohost.vendor.acme_tiny.acme_tiny import get_crt as sign_certificate
 
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 
 from yunohost.utils.network import get_public_ip
@@ -106,8 +105,7 @@ def certificate_status(auth, domain_list, full=False):
         for domain in domain_list:
             # Is it in Yunohost domain list?
             if domain not in yunohost_domains_list:
-                raise MoulinetteError(errno.EINVAL, m18n.n(
-                    'certmanager_domain_unknown', domain=domain))
+                raise YunohostError('certmanager_domain_unknown', domain=domain)
 
     certificates = {}
 
@@ -172,8 +170,7 @@ def _certificate_install_selfsigned(domain_list, force=False):
             status = _get_status(domain)
 
             if status["summary"]["code"] in ('good', 'great'):
-                raise MoulinetteError(errno.EINVAL, m18n.n(
-                    'certmanager_attempt_to_replace_valid_cert', domain=domain))
+                raise YunohostError('certmanager_attempt_to_replace_valid_cert', domain=domain)
 
         operation_logger.start()
 
@@ -203,8 +200,7 @@ def _certificate_install_selfsigned(domain_list, force=False):
 
             if p.returncode != 0:
                 logger.warning(out)
-                raise MoulinetteError(
-                    errno.EIO, m18n.n('domain_cert_gen_failed'))
+                raise YunohostError('domain_cert_gen_failed')
             else:
                 logger.debug(out)
 
@@ -262,14 +258,12 @@ def _certificate_install_letsencrypt(auth, domain_list, force=False, no_checks=F
         for domain in domain_list:
             yunohost_domains_list = yunohost.domain.domain_list(auth)['domains']
             if domain not in yunohost_domains_list:
-                raise MoulinetteError(errno.EINVAL, m18n.n(
-                    'certmanager_domain_unknown', domain=domain))
+                raise YunohostError('certmanager_domain_unknown', domain=domain)
 
             # Is it self-signed?
             status = _get_status(domain)
             if not force and status["CA_type"]["code"] != "self-signed":
-                raise MoulinetteError(errno.EINVAL, m18n.n(
-                    'certmanager_domain_cert_not_selfsigned', domain=domain))
+                raise YunohostError('certmanager_domain_cert_not_selfsigned', domain=domain)
 
     if staging:
         logger.warning(
@@ -349,25 +343,21 @@ def certificate_renew(auth, domain_list, force=False, no_checks=False, email=Fal
 
             # Is it in Yunohost dmomain list?
             if domain not in yunohost.domain.domain_list(auth)['domains']:
-                raise MoulinetteError(errno.EINVAL, m18n.n(
-                    'certmanager_domain_unknown', domain=domain))
+                raise YunohostError('certmanager_domain_unknown', domain=domain)
 
             status = _get_status(domain)
 
             # Does it expire soon?
             if status["validity"] > VALIDITY_LIMIT and not force:
-                raise MoulinetteError(errno.EINVAL, m18n.n(
-                    'certmanager_attempt_to_renew_valid_cert', domain=domain))
+                raise YunohostError('certmanager_attempt_to_renew_valid_cert', domain=domain)
 
             # Does it have a Let's Encrypt cert?
             if status["CA_type"]["code"] != "lets-encrypt":
-                raise MoulinetteError(errno.EINVAL, m18n.n(
-                    'certmanager_attempt_to_renew_nonLE_cert', domain=domain))
+                raise YunohostError('certmanager_attempt_to_renew_nonLE_cert', domain=domain)
 
             # Check ACME challenge configured for given domain
             if not _check_acme_challenge_configuration(domain):
-                raise MoulinetteError(errno.EINVAL, m18n.n(
-                    'certmanager_acme_not_configured_for_domain', domain=domain))
+                raise YunohostError('certmanager_acme_not_configured_for_domain', domain=domain)
 
     if staging:
         logger.warning(
@@ -484,8 +474,7 @@ location ^~ '/.well-known/acme-challenge/'
             contents = f.read()
 
         if '/.well-known/acme-challenge' in contents:
-            raise MoulinetteError(errno.EINVAL, m18n.n(
-                'certmanager_conflicting_nginx_file', filepath=path))
+            raise YunohostError('certmanager_conflicting_nginx_file', filepath=path)
 
     # Write the conf
     if os.path.exists(nginx_conf_file):
@@ -563,25 +552,22 @@ def _fetch_and_enable_new_certificate(domain, staging=False, no_checks=False):
                                               CA=certification_authority)
     except ValueError as e:
         if "urn:acme:error:rateLimited" in str(e):
-            raise MoulinetteError(errno.EINVAL, m18n.n(
-                'certmanager_hit_rate_limit', domain=domain))
+            raise YunohostError('certmanager_hit_rate_limit', domain=domain)
         else:
             logger.error(str(e))
             _display_debug_information(domain)
-            raise MoulinetteError(errno.EINVAL, m18n.n(
-                'certmanager_cert_signing_failed'))
+            raise YunohostError('certmanager_cert_signing_failed')
 
     except Exception as e:
         logger.error(str(e))
 
-        raise MoulinetteError(errno.EINVAL, m18n.n(
-            'certmanager_cert_signing_failed'))
+        raise YunohostError('certmanager_cert_signing_failed')
 
     import requests # lazy loading this module for performance reasons
     try:
         intermediate_certificate = requests.get(INTERMEDIATE_CERTIFICATE_URL, timeout=30).text
     except requests.exceptions.Timeout as e:
-        raise MoulinetteError(errno.EINVAL, m18n.n('certmanager_couldnt_fetch_intermediate_cert'))
+        raise YunohostError('certmanager_couldnt_fetch_intermediate_cert')
 
     # Now save the key and signed certificate
     logger.debug("Saving the key and signed certificate...")
@@ -624,8 +610,7 @@ def _fetch_and_enable_new_certificate(domain, staging=False, no_checks=False):
     status_summary = _get_status(domain)["summary"]
 
     if status_summary["code"] != "great":
-        raise MoulinetteError(errno.EINVAL, m18n.n(
-            'certmanager_certificate_fetching_or_enabling_failed', domain=domain))
+        raise YunohostError('certmanager_certificate_fetching_or_enabling_failed', domain=domain)
 
 
 def _prepare_certificate_signing_request(domain, key_file, output_folder):
@@ -658,8 +643,7 @@ def _get_status(domain):
     cert_file = os.path.join(CERT_FOLDER, domain, "crt.pem")
 
     if not os.path.isfile(cert_file):
-        raise MoulinetteError(errno.EINVAL, m18n.n(
-            'certmanager_no_cert_file', domain=domain, file=cert_file))
+        raise YunohostError('certmanager_no_cert_file', domain=domain, file=cert_file)
 
     from OpenSSL import crypto # lazy loading this module for performance reasons
     try:
@@ -668,8 +652,7 @@ def _get_status(domain):
     except Exception as exception:
         import traceback
         traceback.print_exc(file=sys.stdout)
-        raise MoulinetteError(errno.EINVAL, m18n.n(
-            'certmanager_cannot_read_cert', domain=domain, file=cert_file, reason=exception))
+        raise YunohostError('certmanager_cannot_read_cert', domain=domain, file=cert_file, reason=exception)
 
     cert_subject = cert.get_subject().CN
     cert_issuer = cert.get_issuer().CN
@@ -830,13 +813,11 @@ def _check_domain_is_ready_for_ACME(domain):
 
     # Check if IP from DNS matches public IP
     if not _dns_ip_match_public_ip(public_ip, domain):
-        raise MoulinetteError(errno.EINVAL, m18n.n(
-            'certmanager_domain_dns_ip_differs_from_public_ip', domain=domain))
+        raise YunohostError('certmanager_domain_dns_ip_differs_from_public_ip', domain=domain)
 
     # Check if domain seems to be accessible through HTTP?
     if not _domain_is_accessible_through_HTTP(public_ip, domain):
-        raise MoulinetteError(errno.EINVAL, m18n.n(
-            'certmanager_domain_http_not_working', domain=domain))
+        raise YunohostError('certmanager_domain_http_not_working', domain=domain)
 
 
 def _get_dns_ip(domain):
@@ -845,8 +826,7 @@ def _get_dns_ip(domain):
         resolver.nameservers = DNS_RESOLVERS
         answers = resolver.query(domain, "A")
     except (dns.resolver.NoAnswer, dns.resolver.NXDOMAIN):
-        raise MoulinetteError(errno.EINVAL, m18n.n(
-            'certmanager_error_no_A_record', domain=domain))
+        raise YunohostError('certmanager_error_no_A_record', domain=domain)
 
     return str(answers[0])
 
diff --git a/src/yunohost/data_migrations/0002_migrate_to_tsig_sha256.py b/src/yunohost/data_migrations/0002_migrate_to_tsig_sha256.py
index 5cbc4494f..39e4d2afe 100644
--- a/src/yunohost/data_migrations/0002_migrate_to_tsig_sha256.py
+++ b/src/yunohost/data_migrations/0002_migrate_to_tsig_sha256.py
@@ -4,10 +4,9 @@ import requests
 import base64
 import time
 import json
-import errno
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 
 from yunohost.tools import Migration
@@ -29,7 +28,7 @@ class MyMigration(Migration):
             try:
                 (domain, private_key_path) = _guess_current_dyndns_domain(dyn_host)
                 assert "+157" in private_key_path
-            except (MoulinetteError, AssertionError):
+            except (YunohostError, AssertionError):
                 logger.info(m18n.n("migrate_tsig_not_needed"))
                 return
 
@@ -52,7 +51,7 @@ class MyMigration(Migration):
                                'public_key_sha512': base64.b64encode(public_key_sha512),
                              }, timeout=30)
         except requests.ConnectionError:
-            raise MoulinetteError(errno.ENETUNREACH, m18n.n('no_internet_connection'))
+            raise YunohostError('no_internet_connection')
 
         if r.status_code != 201:
             try:
@@ -70,8 +69,8 @@ class MyMigration(Migration):
             # Migration didn't succeed, so we rollback and raise an exception
             os.system("mv /etc/yunohost/dyndns/*+165* /tmp")
 
-            raise MoulinetteError(m18n.n('migrate_tsig_failed', domain=domain,
-                                  error_code=str(r.status_code), error=error))
+            raise YunohostError('migrate_tsig_failed', domain=domain,
+                                  error_code=str(r.status_code), error=error)
 
         # remove old certificates
         os.system("mv /etc/yunohost/dyndns/*+157* /tmp")
diff --git a/src/yunohost/data_migrations/0003_migrate_to_stretch.py b/src/yunohost/data_migrations/0003_migrate_to_stretch.py
index 26f91ae0b..80d182fbe 100644
--- a/src/yunohost/data_migrations/0003_migrate_to_stretch.py
+++ b/src/yunohost/data_migrations/0003_migrate_to_stretch.py
@@ -3,7 +3,7 @@ import os
 from shutil import copy2
 
 from moulinette import m18n, msettings
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.process import check_output, call_async_output
 from moulinette.utils.filesystem import read_file
@@ -30,7 +30,7 @@ class MyMigration(Migration):
 
     def backward(self):
 
-        raise MoulinetteError(m18n.n("migration_0003_backward_impossible"))
+        raise YunohostError("migration_0003_backward_impossible")
 
     def migrate(self):
 
@@ -57,7 +57,7 @@ class MyMigration(Migration):
         self.apt_dist_upgrade(conf_flags=["old", "miss", "def"])
         _run_service_command("start", "mysql")
         if self.debian_major_version() == 8:
-            raise MoulinetteError(m18n.n("migration_0003_still_on_jessie_after_main_upgrade", log=self.logfile))
+            raise YunohostError("migration_0003_still_on_jessie_after_main_upgrade", log=self.logfile)
 
         # Specific upgrade for fail2ban...
         logger.info(m18n.n("migration_0003_fail2ban_upgrade"))
@@ -107,11 +107,11 @@ class MyMigration(Migration):
         # would still be in 2.x...
         if not self.debian_major_version() == 8 \
            and not self.yunohost_major_version() == 2:
-            raise MoulinetteError(m18n.n("migration_0003_not_jessie"))
+            raise YunohostError("migration_0003_not_jessie")
 
         # Have > 1 Go free space on /var/ ?
         if free_space_in_directory("/var/") / (1024**3) < 1.0:
-            raise MoulinetteError(m18n.n("migration_0003_not_enough_free_space"))
+            raise YunohostError("migration_0003_not_enough_free_space")
 
         # Check system is up to date
         # (but we don't if 'stretch' is already in the sources.list ...
@@ -120,7 +120,7 @@ class MyMigration(Migration):
             self.apt_update()
             apt_list_upgradable = check_output("apt list --upgradable -a")
             if "upgradable" in apt_list_upgradable:
-                raise MoulinetteError(m18n.n("migration_0003_system_not_fully_up_to_date"))
+                raise YunohostError("migration_0003_system_not_fully_up_to_date")
 
     @property
     def disclaimer(self):
diff --git a/src/yunohost/data_migrations/0005_postgresql_9p4_to_9p6.py b/src/yunohost/data_migrations/0005_postgresql_9p4_to_9p6.py
index 871edcd19..0208b717e 100644
--- a/src/yunohost/data_migrations/0005_postgresql_9p4_to_9p6.py
+++ b/src/yunohost/data_migrations/0005_postgresql_9p4_to_9p6.py
@@ -1,7 +1,7 @@
 import subprocess
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 
 from yunohost.tools import Migration
@@ -20,10 +20,10 @@ class MyMigration(Migration):
             return
 
         if not self.package_is_installed("postgresql-9.6"):
-            raise MoulinetteError(m18n.n("migration_0005_postgresql_96_not_installed"))
+            raise YunohostError("migration_0005_postgresql_96_not_installed")
 
         if not space_used_by_directory("/var/lib/postgresql/9.4") > free_space_in_directory("/var/lib/postgresql"):
-            raise MoulinetteError(m18n.n("migration_0005_not_enough_space", path="/var/lib/postgresql/"))
+            raise YunohostError("migration_0005_not_enough_space", path="/var/lib/postgresql/")
 
         subprocess.check_call("service postgresql stop", shell=True)
         subprocess.check_call("pg_dropcluster --stop 9.6 main", shell=True)
diff --git a/src/yunohost/data_migrations/0006_sync_admin_and_root_passwords.py b/src/yunohost/data_migrations/0006_sync_admin_and_root_passwords.py
index ee3aeefcb..1149f28d5 100644
--- a/src/yunohost/data_migrations/0006_sync_admin_and_root_passwords.py
+++ b/src/yunohost/data_migrations/0006_sync_admin_and_root_passwords.py
@@ -5,7 +5,7 @@ import string
 import subprocess
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.process import run_commands, check_output
 from moulinette.utils.filesystem import append_to_file
diff --git a/src/yunohost/data_migrations/0007_ssh_conf_managed_by_yunohost_step1.py b/src/yunohost/data_migrations/0007_ssh_conf_managed_by_yunohost_step1.py
index 73cb162b6..306e47672 100644
--- a/src/yunohost/data_migrations/0007_ssh_conf_managed_by_yunohost_step1.py
+++ b/src/yunohost/data_migrations/0007_ssh_conf_managed_by_yunohost_step1.py
@@ -4,7 +4,6 @@ import re
 from shutil import copyfile
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.filesystem import mkdir, rm
 
@@ -12,6 +11,7 @@ from yunohost.tools import Migration
 from yunohost.service import service_regen_conf, _get_conf_hashes, \
                              _calculate_hash, _run_service_command
 from yunohost.settings import settings_set
+from yunohost.utils.error import YunohostError
 
 logger = getActionLogger('yunohost.migration')
 
@@ -67,11 +67,11 @@ class MyMigration(Migration):
         # Restart ssh and backward if it fail
         if not _run_service_command('restart', 'ssh'):
             self.backward()
-            raise MoulinetteError(m18n.n("migration_0007_cancel"))
+            raise YunohostError("migration_0007_cancel")
 
     def backward(self):
 
         # We don't backward completely but it should be enough
         copyfile('/etc/ssh/sshd_config.bkp', SSHD_CONF)
         if not _run_service_command('restart', 'ssh'):
-            raise MoulinetteError(m18n.n("migration_0007_cannot_restart"))
+            raise YunohostError("migration_0007_cannot_restart")
diff --git a/src/yunohost/data_migrations/0008_ssh_conf_managed_by_yunohost_step2.py b/src/yunohost/data_migrations/0008_ssh_conf_managed_by_yunohost_step2.py
index c53154192..5d8fee89c 100644
--- a/src/yunohost/data_migrations/0008_ssh_conf_managed_by_yunohost_step2.py
+++ b/src/yunohost/data_migrations/0008_ssh_conf_managed_by_yunohost_step2.py
@@ -1,13 +1,12 @@
 import re
 
-from moulinette import m18n
-from moulinette.core import MoulinetteError
 from moulinette.utils.log import getActionLogger
 
 from yunohost.tools import Migration
 from yunohost.service import service_regen_conf, _get_conf_hashes, \
                              _calculate_hash
 from yunohost.settings import settings_set, settings_get
+from yunohost.utils.error import YunohostError
 
 logger = getActionLogger('yunohost.migration')
 
@@ -33,7 +32,7 @@ class MyMigration(Migration):
 
     def backward(self):
 
-        raise MoulinetteError(m18n.n("migration_0008_backward_impossible"))
+        raise YunohostError("migration_0008_backward_impossible")
 
     @property
     def mode(self):
diff --git a/src/yunohost/domain.py b/src/yunohost/domain.py
index 7b387618a..515a452a8 100644
--- a/src/yunohost/domain.py
+++ b/src/yunohost/domain.py
@@ -27,10 +27,10 @@ import os
 import re
 import json
 import yaml
-import errno
 
 from moulinette import m18n, msettings
 from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 
 import yunohost.certificate
@@ -78,7 +78,7 @@ def domain_add(operation_logger, auth, domain, dyndns=False):
     try:
         auth.validate_uniqueness({'virtualdomain': domain})
     except MoulinetteError:
-        raise MoulinetteError(errno.EEXIST, m18n.n('domain_exists'))
+        raise YunohostError('domain_exists')
 
     operation_logger.start()
 
@@ -87,16 +87,14 @@ def domain_add(operation_logger, auth, domain, dyndns=False):
 
         # Do not allow to subscribe to multiple dyndns domains...
         if os.path.exists('/etc/cron.d/yunohost-dyndns'):
-            raise MoulinetteError(errno.EPERM,
-                                  m18n.n('domain_dyndns_already_subscribed'))
+            raise YunohostError('domain_dyndns_already_subscribed')
 
         from yunohost.dyndns import dyndns_subscribe, _dyndns_provides
 
         # Check that this domain can effectively be provided by
         # dyndns.yunohost.org. (i.e. is it a nohost.me / noho.st)
         if not _dyndns_provides("dyndns.yunohost.org", domain):
-            raise MoulinetteError(errno.EINVAL,
-                                  m18n.n('domain_dyndns_root_unknown'))
+            raise YunohostError('domain_dyndns_root_unknown')
 
         # Actually subscribe
         dyndns_subscribe(domain=domain)
@@ -110,7 +108,7 @@ def domain_add(operation_logger, auth, domain, dyndns=False):
         }
 
         if not auth.add('virtualdomain=%s,ou=domains' % domain, attr_dict):
-            raise MoulinetteError(errno.EIO, m18n.n('domain_creation_failed'))
+            raise YunohostError('domain_creation_failed')
 
         # Don't regen these conf if we're still in postinstall
         if os.path.exists('/etc/yunohost/installed'):
@@ -147,11 +145,11 @@ def domain_remove(operation_logger, auth, domain, force=False):
     from yunohost.app import app_ssowatconf
 
     if not force and domain not in domain_list(auth)['domains']:
-        raise MoulinetteError(errno.EINVAL, m18n.n('domain_unknown'))
+        raise YunohostError('domain_unknown')
 
     # Check domain is not the main domain
     if domain == _get_maindomain():
-        raise MoulinetteError(errno.EINVAL, m18n.n('domain_cannot_remove_main'))
+        raise YunohostError('domain_cannot_remove_main')
 
     # Check if apps are installed on the domain
     for app in os.listdir('/etc/yunohost/apps/'):
@@ -162,14 +160,13 @@ def domain_remove(operation_logger, auth, domain, force=False):
                 continue
             else:
                 if app_domain == domain:
-                    raise MoulinetteError(errno.EPERM,
-                                          m18n.n('domain_uninstall_app_first'))
+                    raise YunohostError('domain_uninstall_app_first')
 
     operation_logger.start()
     if auth.remove('virtualdomain=' + domain + ',ou=domains') or force:
         os.system('rm -rf /etc/yunohost/certs/%s' % domain)
     else:
-        raise MoulinetteError(errno.EIO, m18n.n('domain_deletion_failed'))
+        raise YunohostError('domain_deletion_failed')
 
     service_regen_conf(names=['nginx', 'metronome', 'dnsmasq', 'postfix'])
     app_ssowatconf(auth)
@@ -246,7 +243,7 @@ def _get_conflicting_apps(auth, domain, path):
 
     # Abort if domain is unknown
     if domain not in domain_list(auth)['domains']:
-        raise MoulinetteError(errno.EINVAL, m18n.n('domain_unknown'))
+        raise YunohostError('domain_unknown')
 
     # This import cannot be put on top of file because it would create a
     # recursive import...
diff --git a/src/yunohost/dyndns.py b/src/yunohost/dyndns.py
index dd652119f..0428eb93c 100644
--- a/src/yunohost/dyndns.py
+++ b/src/yunohost/dyndns.py
@@ -29,7 +29,6 @@ import json
 import glob
 import time
 import base64
-import errno
 import subprocess
 
 from moulinette import m18n
@@ -39,7 +38,7 @@ from moulinette.utils.filesystem import read_file, write_to_file, rm
 from moulinette.utils.network import download_json
 from moulinette.utils.process import check_output
 
-
+from yunohost.utils.error import YunohostError
 from yunohost.domain import _get_maindomain, _build_dns_conf
 from yunohost.utils.network import get_public_ip
 from yunohost.log import is_unit_operation
@@ -77,9 +76,7 @@ def _dyndns_provides(provider, domain):
         dyndomains = download_json('https://%s/domains' % provider, timeout=30)
     except MoulinetteError as e:
         logger.error(str(e))
-        raise MoulinetteError(errno.EIO,
-                              m18n.n('dyndns_could_not_check_provide',
-                                     domain=domain, provider=provider))
+        raise YunohostError('dyndns_could_not_check_provide', domain=domain, provider=provider)
 
     # Extract 'dyndomain' from 'domain', e.g. 'nohost.me' from 'foo.nohost.me'
     dyndomain = '.'.join(domain.split('.')[1:])
@@ -106,9 +103,8 @@ def _dyndns_available(provider, domain):
                           expected_status_code=None)
     except MoulinetteError as e:
         logger.error(str(e))
-        raise MoulinetteError(errno.EIO,
-                              m18n.n('dyndns_could_not_check_available',
-                                     domain=domain, provider=provider))
+        raise YunohostError('dyndns_could_not_check_available',
+                                     domain=domain, provider=provider)
 
     return r == u"Domain %s is available" % domain
 
@@ -130,14 +126,11 @@ def dyndns_subscribe(operation_logger, subscribe_host="dyndns.yunohost.org", dom
 
     # Verify if domain is provided by subscribe_host
     if not _dyndns_provides(subscribe_host, domain):
-        raise MoulinetteError(errno.ENOENT,
-                              m18n.n('dyndns_domain_not_provided',
-                                     domain=domain, provider=subscribe_host))
+        raise YunohostError('dyndns_domain_not_provided', domain=domain, provider=subscribe_host)
 
     # Verify if domain is available
     if not _dyndns_available(subscribe_host, domain):
-        raise MoulinetteError(errno.ENOENT,
-                              m18n.n('dyndns_unavailable', domain=domain))
+        raise YunohostError('dyndns_unavailable', domain=domain)
 
     operation_logger.start()
 
@@ -161,14 +154,13 @@ def dyndns_subscribe(operation_logger, subscribe_host="dyndns.yunohost.org", dom
     try:
         r = requests.post('https://%s/key/%s?key_algo=hmac-sha512' % (subscribe_host, base64.b64encode(key)), data={'subdomain': domain}, timeout=30)
     except requests.ConnectionError:
-        raise MoulinetteError(errno.ENETUNREACH, m18n.n('no_internet_connection'))
+        raise YunohostError('no_internet_connection')
     if r.status_code != 201:
         try:
             error = json.loads(r.text)['error']
         except:
             error = "Server error, code: %s. (Message: \"%s\")" % (r.status_code, r.text)
-        raise MoulinetteError(errno.EPERM,
-                              m18n.n('dyndns_registration_failed', error=error))
+        raise YunohostError('dyndns_registration_failed', error=error)
 
     logger.success(m18n.n('dyndns_registered'))
 
@@ -202,7 +194,7 @@ def dyndns_update(operation_logger, dyn_host="dyndns.yunohost.org", domain=None,
             keys = glob.glob('/etc/yunohost/dyndns/K{0}.+*.private'.format(domain))
 
             if not keys:
-                raise MoulinetteError(errno.EIO, m18n.n('dyndns_key_not_found'))
+                raise YunohostError('dyndns_key_not_found')
 
             key = keys[0]
 
@@ -302,8 +294,7 @@ def dyndns_update(operation_logger, dyn_host="dyndns.yunohost.org", domain=None,
         command = ["/usr/bin/nsupdate", "-k", key, DYNDNS_ZONE]
         subprocess.check_call(command)
     except subprocess.CalledProcessError:
-        raise MoulinetteError(errno.EPERM,
-                              m18n.n('dyndns_ip_update_failed'))
+        raise YunohostError('dyndns_ip_update_failed')
 
     logger.success(m18n.n('dyndns_ip_updated'))
 
@@ -329,7 +320,7 @@ def dyndns_removecron():
     try:
         os.remove("/etc/cron.d/yunohost-dyndns")
     except:
-        raise MoulinetteError(errno.EIO, m18n.n('dyndns_cron_remove_failed'))
+        raise YunohostError('dyndns_cron_remove_failed')
 
     logger.success(m18n.n('dyndns_cron_removed'))
 
@@ -359,5 +350,4 @@ def _guess_current_dyndns_domain(dyn_host):
         else:
             return (_domain, path)
 
-    raise MoulinetteError(errno.EINVAL,
-                          m18n.n('dyndns_no_domain_registered'))
+    raise YunohostError('dyndns_no_domain_registered')
diff --git a/src/yunohost/firewall.py b/src/yunohost/firewall.py
index 0e1cf6e76..f7c6c0875 100644
--- a/src/yunohost/firewall.py
+++ b/src/yunohost/firewall.py
@@ -26,7 +26,6 @@
 import os
 import sys
 import yaml
-import errno
 try:
     import miniupnpc
 except ImportError:
@@ -34,7 +33,7 @@ except ImportError:
     sys.exit(1)
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils import process
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.text import prependlines
@@ -268,7 +267,7 @@ def firewall_reload(skip_upnp=False):
         reloaded = True
 
     if not reloaded:
-        raise MoulinetteError(errno.ESRCH, m18n.n('firewall_reload_failed'))
+        raise YunohostError('firewall_reload_failed')
 
     hook_callback('post_iptable_rules',
                   args=[upnp, os.path.exists("/proc/net/if_inet6")])
@@ -338,7 +337,7 @@ def firewall_upnp(action='status', no_refresh=False):
         if action == 'status':
             no_refresh = True
     else:
-        raise MoulinetteError(errno.EINVAL, m18n.n('action_invalid', action=action))
+        raise YunohostError('action_invalid', action=action)
 
     # Refresh port mapping using UPnP
     if not no_refresh:
@@ -407,7 +406,7 @@ def firewall_upnp(action='status', no_refresh=False):
             firewall_reload(skip_upnp=True)
 
     if action == 'enable' and not enabled:
-        raise MoulinetteError(errno.ENXIO, m18n.n('upnp_port_open_failed'))
+        raise YunohostError('upnp_port_open_failed')
     return {'enabled': enabled}
 
 
@@ -419,7 +418,7 @@ def firewall_stop():
     """
 
     if os.system("iptables -w -P INPUT ACCEPT") != 0:
-        raise MoulinetteError(errno.ESRCH, m18n.n('iptables_unavailable'))
+        raise YunohostError('iptables_unavailable')
 
     os.system("iptables -w -F")
     os.system("iptables -w -X")
diff --git a/src/yunohost/hook.py b/src/yunohost/hook.py
index 46c25d50d..5a6c4c154 100644
--- a/src/yunohost/hook.py
+++ b/src/yunohost/hook.py
@@ -25,12 +25,11 @@
 """
 import os
 import re
-import errno
 import tempfile
 from glob import iglob
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils import log
 
 HOOK_FOLDER = '/usr/share/yunohost/hooks/'
@@ -112,7 +111,7 @@ def hook_info(action, name):
             })
 
     if not hooks:
-        raise MoulinetteError(errno.EINVAL, m18n.n('hook_name_unknown', name=name))
+        raise YunohostError('hook_name_unknown', name=name)
     return {
         'action': action,
         'name': name,
@@ -174,7 +173,7 @@ def hook_list(action, list_by='name', show_info=False):
                 # Add only the name
                 d.add(name)
     else:
-        raise MoulinetteError(errno.EINVAL, m18n.n('hook_list_by_invalid'))
+        raise YunohostError('hook_list_by_invalid')
 
     def _append_folder(d, folder):
         # Iterate over and add hook from a folder
@@ -255,8 +254,7 @@ def hook_callback(action, hooks=[], args=None, no_trace=False, chdir=None,
             try:
                 hl = hooks_names[n]
             except KeyError:
-                raise MoulinetteError(errno.EINVAL,
-                                      m18n.n('hook_name_unknown', n))
+                raise YunohostError('hook_name_unknown', n)
             # Iterate over hooks with this name
             for h in hl:
                 # Update hooks dict
@@ -282,7 +280,7 @@ def hook_callback(action, hooks=[], args=None, no_trace=False, chdir=None,
                                          path=path, args=args)
                 hook_exec(path, args=hook_args, chdir=chdir, env=env,
                           no_trace=no_trace, raise_on_error=True)
-            except MoulinetteError as e:
+            except YunohostError as e:
                 state = 'failed'
                 logger.error(e.strerror, exc_info=1)
                 post_callback(name=name, priority=priority, path=path,
@@ -319,7 +317,7 @@ def hook_exec(path, args=None, raise_on_error=False, no_trace=False,
     if path[0] != '/':
         path = os.path.realpath(path)
     if not os.path.isfile(path):
-        raise MoulinetteError(errno.EIO, m18n.g('file_not_exist', path=path))
+        raise YunohostError('file_not_exist', path=path)
 
     # Construct command variables
     cmd_args = ''
@@ -384,14 +382,12 @@ def hook_exec(path, args=None, raise_on_error=False, no_trace=False,
     # Check and return process' return code
     if returncode is None:
         if raise_on_error:
-            raise MoulinetteError(
-                errno.EIO, m18n.n('hook_exec_not_terminated', path=path))
+            raise YunohostError('hook_exec_not_terminated', path=path)
         else:
             logger.error(m18n.n('hook_exec_not_terminated', path=path))
             return 1
     elif raise_on_error and returncode != 0:
-        raise MoulinetteError(
-            errno.EIO, m18n.n('hook_exec_failed', path=path))
+        raise YunohostError('hook_exec_failed', path=path)
     return returncode
 
 
diff --git a/src/yunohost/log.py b/src/yunohost/log.py
index 80a7a134f..7b32f18dd 100644
--- a/src/yunohost/log.py
+++ b/src/yunohost/log.py
@@ -26,7 +26,6 @@
 
 import os
 import yaml
-import errno
 import collections
 
 from datetime import datetime
@@ -34,7 +33,7 @@ from logging import FileHandler, getLogger, Formatter
 from sys import exc_info
 
 from moulinette import m18n, msettings
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.filesystem import read_file
 
@@ -148,8 +147,7 @@ def log_display(path, number=50, share=False):
         log_path = base_path + LOG_FILE_EXT
 
     if not os.path.exists(md_path) and not os.path.exists(log_path):
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('log_does_exists', log=path))
+        raise YunohostError('log_does_exists', log=path)
 
     infos = {}
 
@@ -189,7 +187,7 @@ def log_display(path, number=50, share=False):
                 if os.path.exists(log_path):
                     logger.warning(error)
                 else:
-                    raise MoulinetteError(errno.EINVAL, error)
+                    raise YunohostError(error)
 
     # Display logs if exist
     if os.path.exists(log_path):
diff --git a/src/yunohost/monitor.py b/src/yunohost/monitor.py
index fc10a4fbc..469ac41f1 100644
--- a/src/yunohost/monitor.py
+++ b/src/yunohost/monitor.py
@@ -31,14 +31,13 @@ import calendar
 import subprocess
 import xmlrpclib
 import os.path
-import errno
 import os
 import dns.resolver
 import cPickle as pickle
 from datetime import datetime
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 
 from yunohost.utils.network import get_public_ip
@@ -83,7 +82,7 @@ def monitor_disk(units=None, mountpoint=None, human_readable=False):
             result_dname = dn
     if len(devices) == 0:
         if mountpoint is not None:
-            raise MoulinetteError(errno.ENODEV, m18n.n('mountpoint_unknown'))
+            raise YunohostError('mountpoint_unknown')
         return result
 
     # Retrieve monitoring for unit(s)
@@ -141,7 +140,7 @@ def monitor_disk(units=None, mountpoint=None, human_readable=False):
             for dname in devices_names:
                 _set(dname, 'not-available')
         else:
-            raise MoulinetteError(errno.EINVAL, m18n.n('unit_unknown', unit=u))
+            raise YunohostError('unit_unknown', unit=u)
 
     if result_dname is not None:
         return result[result_dname]
@@ -237,7 +236,7 @@ def monitor_network(units=None, human_readable=False):
                 'gateway': gateway,
             }
         else:
-            raise MoulinetteError(errno.EINVAL, m18n.n('unit_unknown', unit=u))
+            raise YunohostError('unit_unknown', unit=u)
 
     if len(units) == 1:
         return result[units[0]]
@@ -287,7 +286,7 @@ def monitor_system(units=None, human_readable=False):
         elif u == 'infos':
             result[u] = json.loads(glances.getSystem())
         else:
-            raise MoulinetteError(errno.EINVAL, m18n.n('unit_unknown', unit=u))
+            raise YunohostError('unit_unknown', unit=u)
 
     if len(units) == 1 and type(result[units[0]]) is not str:
         return result[units[0]]
@@ -303,7 +302,7 @@ def monitor_update_stats(period):
 
     """
     if period not in ['day', 'week', 'month']:
-        raise MoulinetteError(errno.EINVAL, m18n.n('monitor_period_invalid'))
+        raise YunohostError('monitor_period_invalid')
 
     stats = _retrieve_stats(period)
     if not stats:
@@ -321,7 +320,7 @@ def monitor_update_stats(period):
         else:
             monitor = _monitor_all(p, 0)
     if not monitor:
-        raise MoulinetteError(errno.ENODATA, m18n.n('monitor_stats_no_update'))
+        raise YunohostError('monitor_stats_no_update')
 
     stats['timestamp'].append(time.time())
 
@@ -386,15 +385,13 @@ def monitor_show_stats(period, date=None):
 
     """
     if period not in ['day', 'week', 'month']:
-        raise MoulinetteError(errno.EINVAL, m18n.n('monitor_period_invalid'))
+        raise YunohostError('monitor_period_invalid')
 
     result = _retrieve_stats(period, date)
     if result is False:
-        raise MoulinetteError(errno.ENOENT,
-                              m18n.n('monitor_stats_file_not_found'))
+        raise YunohostError('monitor_stats_file_not_found')
     elif result is None:
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('monitor_stats_period_unavailable'))
+        raise YunohostError('monitor_stats_period_unavailable')
     return result
 
 
@@ -442,7 +439,7 @@ def monitor_disable():
     if glances['loaded'] != 'disabled':
         try:
             service_disable('glances')
-        except MoulinetteError as e:
+        except YunohostError as e:
             logger.warning(e.strerror)
 
     # Remove crontab
@@ -470,8 +467,8 @@ def _get_glances_api():
     from yunohost.service import service_status
 
     if service_status('glances')['status'] != 'running':
-        raise MoulinetteError(errno.EPERM, m18n.n('monitor_not_enabled'))
-    raise MoulinetteError(errno.EIO, m18n.n('monitor_glances_con_failed'))
+        raise YunohostError('monitor_not_enabled')
+    raise YunohostError('monitor_glances_con_failed')
 
 
 def _extract_inet(string, skip_netmask=False, skip_loopback=True):
diff --git a/src/yunohost/service.py b/src/yunohost/service.py
index 83c36d0f8..b2c18c74e 100644
--- a/src/yunohost/service.py
+++ b/src/yunohost/service.py
@@ -28,7 +28,6 @@ import time
 import yaml
 import json
 import subprocess
-import errno
 import shutil
 import hashlib
 
@@ -36,7 +35,7 @@ from difflib import unified_diff
 from datetime import datetime
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils import log, filesystem
 
 from yunohost.log import is_unit_operation
@@ -85,7 +84,7 @@ def service_add(name, status=None, log=None, runlevel=None, need_lock=False, des
         _save_services(services)
     except:
         # we'll get a logger.warning with more details in _save_services
-        raise MoulinetteError(errno.EIO, m18n.n('service_add_failed', service=name))
+        raise YunohostError('service_add_failed', service=name)
 
     logger.success(m18n.n('service_added', service=name))
 
@@ -103,13 +102,13 @@ def service_remove(name):
     try:
         del services[name]
     except KeyError:
-        raise MoulinetteError(errno.EINVAL, m18n.n('service_unknown', service=name))
+        raise YunohostError('service_unknown', service=name)
 
     try:
         _save_services(services)
     except:
         # we'll get a logger.warning with more details in _save_services
-        raise MoulinetteError(errno.EIO, m18n.n('service_remove_failed', service=name))
+        raise YunohostError('service_remove_failed', service=name)
 
     logger.success(m18n.n('service_removed', service=name))
 
@@ -130,10 +129,7 @@ def service_start(names):
             logger.success(m18n.n('service_started', service=name))
         else:
             if service_status(name)['status'] != 'running':
-                raise MoulinetteError(errno.EPERM,
-                                      m18n.n('service_start_failed',
-                                             service=name,
-                                             logs=_get_journalctl_logs(name)))
+                raise YunohostError('service_start_failed', service=name, logs=_get_journalctl_logs(name))
             logger.debug(m18n.n('service_already_started', service=name))
 
 
@@ -152,10 +148,7 @@ def service_stop(names):
             logger.success(m18n.n('service_stopped', service=name))
         else:
             if service_status(name)['status'] != 'inactive':
-                raise MoulinetteError(errno.EPERM,
-                                      m18n.n('service_stop_failed',
-                                             service=name,
-                                             logs=_get_journalctl_logs(name)))
+                raise YunohostError('service_stop_failed', service=name, logs=_get_journalctl_logs(name))
             logger.debug(m18n.n('service_already_stopped', service=name))
 
 @is_unit_operation()
@@ -174,10 +167,7 @@ def service_enable(operation_logger, names):
         if _run_service_command('enable', name):
             logger.success(m18n.n('service_enabled', service=name))
         else:
-            raise MoulinetteError(errno.EPERM,
-                                  m18n.n('service_enable_failed',
-                                         service=name,
-                                         logs=_get_journalctl_logs(name)))
+            raise YunohostError('service_enable_failed', service=name, logs=_get_journalctl_logs(name))
 
 
 def service_disable(names):
@@ -194,10 +184,7 @@ def service_disable(names):
         if _run_service_command('disable', name):
             logger.success(m18n.n('service_disabled', service=name))
         else:
-            raise MoulinetteError(errno.EPERM,
-                                  m18n.n('service_disable_failed',
-                                         service=name,
-                                         logs=_get_journalctl_logs(name)))
+            raise YunohostError('service_disable_failed', service=name, logs=_get_journalctl_logs(name))
 
 
 def service_status(names=[]):
@@ -220,8 +207,7 @@ def service_status(names=[]):
 
     for name in names:
         if check_names and name not in services.keys():
-            raise MoulinetteError(errno.EINVAL,
-                                  m18n.n('service_unknown', service=name))
+            raise YunohostError('service_unknown', service=name)
 
         # this "service" isn't a service actually so we skip it
         #
@@ -320,10 +306,10 @@ def service_log(name, number=50):
     services = _get_services()
 
     if name not in services.keys():
-        raise MoulinetteError(errno.EINVAL, m18n.n('service_unknown', service=name))
+        raise YunohostError('service_unknown', service=name)
 
     if 'log' not in services[name]:
-        raise MoulinetteError(errno.EPERM, m18n.n('service_no_log', service=name))
+        raise YunohostError('service_no_log', service=name)
 
     log_list = services[name]['log']
 
@@ -431,9 +417,8 @@ def service_regen_conf(operation_logger, names=[], with_diff=False, force=False,
     names = pre_result['succeed'].keys()
 
     if not names:
-        raise MoulinetteError(errno.EIO,
-                              m18n.n('service_regenconf_failed',
-                                     services=', '.join(pre_result['failed'])))
+        raise YunohostError('service_regenconf_failed',
+                                     services=', '.join(pre_result['failed']))
 
     # Set the processing method
     _regen = _process_regen_conf if not dry_run else lambda *a, **k: True
@@ -609,7 +594,7 @@ def _run_service_command(action, service):
     """
     services = _get_services()
     if service not in services.keys():
-        raise MoulinetteError(errno.EINVAL, m18n.n('service_unknown', service=service))
+        raise YunohostError('service_unknown', service=service)
 
     possible_actions = ['start', 'stop', 'restart', 'reload', 'enable', 'disable']
     if action not in possible_actions:
diff --git a/src/yunohost/settings.py b/src/yunohost/settings.py
index fcb08485e..c48f567ab 100644
--- a/src/yunohost/settings.py
+++ b/src/yunohost/settings.py
@@ -1,12 +1,11 @@
 import os
 import json
-import errno
 
 from datetime import datetime
 from collections import OrderedDict
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 
 logger = getActionLogger('yunohost.settings')
@@ -54,8 +53,7 @@ def settings_get(key, full=False):
     settings = _get_settings()
 
     if key not in settings:
-        raise MoulinetteError(errno.EINVAL, m18n.n(
-            'global_settings_key_doesnt_exists', settings_key=key))
+        raise YunohostError('global_settings_key_doesnt_exists', settings_key=key)
 
     if full:
         return settings[key]
@@ -83,44 +81,39 @@ def settings_set(key, value):
     settings = _get_settings()
 
     if key not in settings:
-        raise MoulinetteError(errno.EINVAL, m18n.n(
-            'global_settings_key_doesnt_exists', settings_key=key))
+        raise YunohostError('global_settings_key_doesnt_exists', settings_key=key)
 
     key_type = settings[key]["type"]
 
     if key_type == "bool":
         if not isinstance(value, bool):
-            raise MoulinetteError(errno.EINVAL, m18n.n(
-                'global_settings_bad_type_for_setting', setting=key,
-                received_type=type(value).__name__, expected_type=key_type))
+            raise YunohostError('global_settings_bad_type_for_setting', setting=key,
+                received_type=type(value).__name__, expected_type=key_type)
     elif key_type == "int":
         if not isinstance(value, int) or isinstance(value, bool):
             if isinstance(value, str):
                 try:
                     value=int(value)
                 except:
-                    raise MoulinetteError(errno.EINVAL, m18n.n(
-                        'global_settings_bad_type_for_setting', setting=key,
-                        received_type=type(value).__name__, expected_type=key_type))
+                    raise YunohostError('global_settings_bad_type_for_setting',
+                                        setting=key,
+                                        received_type=type(value).__name__,
+                                        expected_type=key_type)
             else:
-                raise MoulinetteError(errno.EINVAL, m18n.n(
-                    'global_settings_bad_type_for_setting', setting=key,
-                    received_type=type(value).__name__, expected_type=key_type))
+                raise YunohostError('global_settings_bad_type_for_setting', setting=key,
+                    received_type=type(value).__name__, expected_type=key_type)
     elif key_type == "string":
         if not isinstance(value, basestring):
-            raise MoulinetteError(errno.EINVAL, m18n.n(
-                'global_settings_bad_type_for_setting', setting=key,
-                received_type=type(value).__name__, expected_type=key_type))
+            raise YunohostError('global_settings_bad_type_for_setting', setting=key,
+                received_type=type(value).__name__, expected_type=key_type)
     elif key_type == "enum":
         if value not in settings[key]["choices"]:
-            raise MoulinetteError(errno.EINVAL, m18n.n(
-                'global_settings_bad_choice_for_enum', setting=key,
+            raise YunohostError('global_settings_bad_choice_for_enum', setting=key,
                 received_type=type(value).__name__,
-                expected_type=", ".join(settings[key]["choices"])))
+                expected_type=", ".join(settings[key]["choices"]))
     else:
-        raise MoulinetteError(errno.EINVAL, m18n.n(
-            'global_settings_unknown_type', setting=key,
-            unknown_type=key_type))
+        raise YunohostError('global_settings_unknown_type', setting=key,
+            unknown_type=key_type)
 
     settings[key]["value"] = value
 
@@ -138,8 +131,7 @@ def settings_reset(key):
     settings = _get_settings()
 
     if key not in settings:
-        raise MoulinetteError(errno.EINVAL, m18n.n(
-            'global_settings_key_doesnt_exists', settings_key=key))
+        raise YunohostError('global_settings_key_doesnt_exists', settings_key=key)
 
     settings[key]["value"] = settings[key]["default"]
     _save_settings(settings)
@@ -215,8 +207,7 @@ def _get_settings():
                                           setting_key=key))
                     unknown_settings[key] = value
     except Exception as e:
-        raise MoulinetteError(errno.EIO, m18n.n('global_settings_cant_open_settings', reason=e),
-                              exc_info=1)
+        raise YunohostError('global_settings_cant_open_settings', reason=e)
 
     if unknown_settings:
         try:
@@ -237,14 +228,10 @@ def _save_settings(settings, location=SETTINGS_PATH):
     try:
         result = json.dumps(settings_without_description, indent=4)
     except Exception as e:
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('global_settings_cant_serialize_settings', reason=e),
-                              exc_info=1)
+        raise YunohostError('global_settings_cant_serialize_settings', reason=e)
 
     try:
         with open(location, "w") as settings_fd:
             settings_fd.write(result)
     except Exception as e:
-        raise MoulinetteError(errno.EIO,
-                              m18n.n('global_settings_cant_write_settings', reason=e),
-                              exc_info=1)
+        raise YunohostError('global_settings_cant_write_settings', reason=e)
diff --git a/src/yunohost/ssh.py b/src/yunohost/ssh.py
index 5ddebfc2f..a9e5babf7 100644
--- a/src/yunohost/ssh.py
+++ b/src/yunohost/ssh.py
@@ -2,12 +2,11 @@
 
 import re
 import os
-import errno
 import pwd
 import subprocess
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.filesystem import read_file, write_to_file, chown, chmod, mkdir
 
 SSHD_CONFIG_PATH = "/etc/ssh/sshd_config"
@@ -23,7 +22,7 @@ def user_ssh_allow(auth, username):
     # TODO it would be good to support different kind of shells
 
     if not _get_user_for_ssh(auth, username):
-        raise MoulinetteError(errno.EINVAL, m18n.n('user_unknown', user=username))
+        raise YunohostError('user_unknown', user=username)
 
     auth.update('uid=%s,ou=users' % username, {'loginShell': '/bin/bash'})
 
@@ -42,7 +41,7 @@ def user_ssh_disallow(auth, username):
     # TODO it would be good to support different kind of shells
 
     if not _get_user_for_ssh(auth, username):
-        raise MoulinetteError(errno.EINVAL, m18n.n('user_unknown', user=username))
+        raise YunohostError('user_unknown', user=username)
 
     auth.update('uid=%s,ou=users' % username, {'loginShell': '/bin/false'})
 
diff --git a/src/yunohost/tests/test_appslist.py b/src/yunohost/tests/test_appslist.py
index 6b7141f4a..7a6f27d6c 100644
--- a/src/yunohost/tests/test_appslist.py
+++ b/src/yunohost/tests/test_appslist.py
@@ -5,7 +5,7 @@ import requests_mock
 import glob
 import time
 
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 
 from yunohost.app import app_fetchlist, app_removelist, app_listlists, _using_legacy_appslist_system, _migrate_appslist_system, _register_new_appslist
 
@@ -79,7 +79,7 @@ def test_appslist_list_register_conflict_name():
     """
 
     _register_new_appslist("https://lol.com/appslist.json", "dummy")
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         _register_new_appslist("https://lol.com/appslist2.json", "dummy")
 
     appslist_dict = app_listlists()
@@ -94,7 +94,7 @@ def test_appslist_list_register_conflict_url():
     """
 
     _register_new_appslist("https://lol.com/appslist.json", "dummy")
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         _register_new_appslist("https://lol.com/appslist.json", "plopette")
 
     appslist_dict = app_listlists()
@@ -161,7 +161,7 @@ def test_appslist_fetch_unknownlist():
 
     assert app_listlists() == {}
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         app_fetchlist(name="swag")
 
 
@@ -170,7 +170,7 @@ def test_appslist_fetch_url_but_no_name():
     Do a fetchlist with url given, but no name given
     """
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         app_fetchlist(url=URL_OFFICIAL_APP_LIST)
 
 
@@ -270,7 +270,7 @@ def test_appslist_remove_unknown():
     Attempt to remove an unknown list
     """
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         app_removelist("dummy")
 
 
diff --git a/src/yunohost/tests/test_appurl.py b/src/yunohost/tests/test_appurl.py
index dc1dbc29b..85f290b5d 100644
--- a/src/yunohost/tests/test_appurl.py
+++ b/src/yunohost/tests/test_appurl.py
@@ -1,7 +1,7 @@
 import pytest
 
-from moulinette.core import MoulinetteError, init_authenticator
-
+from moulinette.core import init_authenticator
+from yunohost.utils.error import YunohostError
 from yunohost.app import app_install, app_remove
 from yunohost.domain import _get_maindomain, domain_url_available, _normalize_domain_path
 
@@ -43,7 +43,7 @@ def test_urlavailable():
     assert domain_url_available(auth, maindomain, "/macnuggets")
 
     # We don't know the domain yolo.swag
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         assert domain_url_available(auth, "yolo.swag", "/macnuggets")
 
 
@@ -55,13 +55,13 @@ def test_registerurl():
     assert not domain_url_available(auth, maindomain, "/urlregisterapp")
 
     # Try installing at same location
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         app_install(auth, "./tests/apps/register_url_app_ynh",
                 args="domain=%s&path=%s" % (maindomain, "/urlregisterapp"))
 
 
 def test_registerurl_baddomain():
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         app_install(auth, "./tests/apps/register_url_app_ynh",
                 args="domain=%s&path=%s" % ("yolo.swag", "/urlregisterapp"))
diff --git a/src/yunohost/tests/test_backuprestore.py b/src/yunohost/tests/test_backuprestore.py
index c9d4c6b15..a2356318d 100644
--- a/src/yunohost/tests/test_backuprestore.py
+++ b/src/yunohost/tests/test_backuprestore.py
@@ -12,7 +12,7 @@ from yunohost.app import app_install, app_remove, app_ssowatconf
 from yunohost.app import _is_installed
 from yunohost.backup import backup_create, backup_restore, backup_list, backup_info, backup_delete
 from yunohost.domain import _get_maindomain
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 
 # Get main domain
 maindomain = ""
@@ -214,7 +214,7 @@ def test_backup_system_part_that_does_not_exists(mocker):
     mocker.spy(m18n, "n")
 
     # Create the backup
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_create(system=["yolol"], apps=None)
 
     m18n.n.assert_any_call('backup_hook_unknown', hook="yolol")
@@ -295,7 +295,7 @@ def test_backup_script_failure_handling(monkeypatch, mocker):
     monkeypatch.setattr("yunohost.backup.hook_exec", custom_hook_exec)
     mocker.spy(m18n, "n")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_create(system=None, apps=["backup_recommended_app"])
 
     m18n.n.assert_any_call('backup_app_failed', app='backup_recommended_app')
@@ -315,7 +315,7 @@ def test_backup_not_enough_free_space(monkeypatch, mocker):
 
     mocker.spy(m18n, "n")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_create(system=None, apps=["backup_recommended_app"])
 
     m18n.n.assert_any_call('not_enough_disk_space', path=ANY)
@@ -327,7 +327,7 @@ def test_backup_app_not_installed(mocker):
 
     mocker.spy(m18n, "n")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_create(system=None, apps=["wordpress"])
 
     m18n.n.assert_any_call("unbackup_app", app="wordpress")
@@ -343,7 +343,7 @@ def test_backup_app_with_no_backup_script(mocker):
 
     mocker.spy(m18n, "n")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_create(system=None, apps=["backup_recommended_app"])
 
     m18n.n.assert_any_call("backup_with_no_backup_script_for_app", app="backup_recommended_app")
@@ -420,7 +420,7 @@ def test_restore_app_script_failure_handling(monkeypatch, mocker):
 
     assert not _is_installed("wordpress")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_restore(auth, system=None, name=backup_list()["archives"][0],
                              apps=["wordpress"])
 
@@ -441,7 +441,7 @@ def test_restore_app_not_enough_free_space(monkeypatch, mocker):
 
     assert not _is_installed("wordpress")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_restore(auth, system=None, name=backup_list()["archives"][0],
                              apps=["wordpress"])
 
@@ -460,7 +460,7 @@ def test_restore_app_not_in_backup(mocker):
 
     mocker.spy(m18n, "n")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_restore(auth, system=None, name=backup_list()["archives"][0],
                              apps=["yoloswag"])
 
@@ -480,7 +480,7 @@ def test_restore_app_already_installed(mocker):
     assert _is_installed("wordpress")
 
     mocker.spy(m18n, "n")
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_restore(auth, system=None, name=backup_list()["archives"][0],
                              apps=["wordpress"])
 
@@ -544,7 +544,7 @@ def test_restore_archive_with_no_json(mocker):
     assert "badbackup" in backup_list()["archives"]
 
     mocker.spy(m18n, "n")
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_restore(auth, name="badbackup", force=True)
     m18n.n.assert_any_call('backup_invalid_archive')
 
diff --git a/src/yunohost/tests/test_changeurl.py b/src/yunohost/tests/test_changeurl.py
index eb10cd604..826ec659b 100644
--- a/src/yunohost/tests/test_changeurl.py
+++ b/src/yunohost/tests/test_changeurl.py
@@ -6,7 +6,7 @@ from moulinette.core import init_authenticator
 from yunohost.app import app_install, app_change_url, app_remove, app_map
 from yunohost.domain import _get_maindomain
 
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 
 # Instantiate LDAP Authenticator
 AUTH_IDENTIFIER = ('ldap', 'ldap-anonymous')
@@ -57,5 +57,5 @@ def test_appchangeurl_sameurl():
     install_changeurl_app("/changeurl")
     check_changeurl_app("/changeurl")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         app_change_url(auth, "change_url_app", maindomain, "changeurl")
diff --git a/src/yunohost/tests/test_settings.py b/src/yunohost/tests/test_settings.py
index 746f5a9d4..afb9faee9 100644
--- a/src/yunohost/tests/test_settings.py
+++ b/src/yunohost/tests/test_settings.py
@@ -2,7 +2,7 @@ import os
 import json
 import pytest
 
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 
 from yunohost.settings import settings_get, settings_list, _get_settings, \
     settings_set, settings_reset, settings_reset_all, \
@@ -46,7 +46,7 @@ def test_settings_get_full_enum():
 
 
 def test_settings_get_doesnt_exists():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_get("doesnt.exists")
 
 
@@ -70,39 +70,39 @@ def test_settings_set_enum():
 
 
 def test_settings_set_doesexit():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("doesnt.exist", True)
 
 
 def test_settings_set_bad_type_bool():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.bool", 42)
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.bool", "pouet")
 
 
 def test_settings_set_bad_type_int():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.int", True)
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.int", "pouet")
 
 
 def test_settings_set_bad_type_string():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.string", True)
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.string", 42)
 
 
 def test_settings_set_bad_value_enum():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.enum", True)
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.enum", "e")
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.enum", 42)
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.enum", "pouet")
 
 
@@ -119,7 +119,7 @@ def test_reset():
 
 
 def test_settings_reset_doesexit():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_reset("doesnt.exist")
 
 
diff --git a/src/yunohost/tools.py b/src/yunohost/tools.py
index 397e51eb2..58bdd23d3 100644
--- a/src/yunohost/tools.py
+++ b/src/yunohost/tools.py
@@ -27,7 +27,6 @@ import re
 import os
 import yaml
 import json
-import errno
 import logging
 import subprocess
 import pwd
@@ -40,7 +39,8 @@ import apt
 import apt.progress
 
 from moulinette import msettings, msignals, m18n
-from moulinette.core import MoulinetteError, init_authenticator
+from moulinette.core import init_authenticator
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.process import check_output
 from moulinette.utils.filesystem import read_json, write_to_json
@@ -112,7 +112,7 @@ def tools_ldapinit():
         pwd.getpwnam("admin")
     except KeyError:
         logger.error(m18n.n('ldap_init_failed_to_create_admin'))
-        raise MoulinetteError(errno.EINVAL, m18n.n('installation_failed'))
+        raise YunohostError('installation_failed')
 
     logger.success(m18n.n('ldap_initialized'))
     return auth
@@ -139,8 +139,7 @@ def tools_adminpw(auth, new_password, check_strength=True):
         auth.update("cn=admin", { "userPassword": new_hash, })
     except:
         logger.exception('unable to change admin password')
-        raise MoulinetteError(errno.EPERM,
-                              m18n.n('admin_password_change_failed'))
+        raise YunohostError('admin_password_change_failed')
     else:
         # Write as root password
         try:
@@ -176,7 +175,7 @@ def tools_maindomain(operation_logger, auth, new_domain=None):
 
     # Check domain exists
     if new_domain not in domain_list(auth)['domains']:
-        raise MoulinetteError(errno.EINVAL, m18n.n('domain_unknown'))
+        raise YunohostError('domain_unknown')
 
     operation_logger.related_to.append(('domain', new_domain))
     operation_logger.start()
@@ -199,7 +198,7 @@ def tools_maindomain(operation_logger, auth, new_domain=None):
         _set_maindomain(new_domain)
     except Exception as e:
         logger.warning("%s" % e, exc_info=1)
-        raise MoulinetteError(errno.EPERM, m18n.n('maindomain_change_failed'))
+        raise YunohostError('maindomain_change_failed')
 
     _set_hostname(new_domain)
 
@@ -248,7 +247,7 @@ def _set_hostname(hostname, pretty_hostname=None):
         if p.returncode != 0:
             logger.warning(command)
             logger.warning(out)
-            raise MoulinetteError(errno.EIO, m18n.n('domain_hostname_failed'))
+            raise YunohostError('domain_hostname_failed')
         else:
             logger.debug(out)
 
@@ -289,8 +288,7 @@ def tools_postinstall(operation_logger, domain, password, ignore_dyndns=False,
 
     # Do some checks at first
     if os.path.isfile('/etc/yunohost/installed'):
-        raise MoulinetteError(errno.EPERM,
-                              m18n.n('yunohost_already_installed'))
+        raise YunohostError('yunohost_already_installed')
 
     # Check password
     if not force_password:
@@ -319,9 +317,7 @@ def tools_postinstall(operation_logger, domain, password, ignore_dyndns=False,
                 dyndns = True
             # If not, abort the postinstall
             else:
-                raise MoulinetteError(errno.EEXIST,
-                                      m18n.n('dyndns_unavailable',
-                                             domain=domain))
+                raise YunohostError('dyndns_unavailable', domain=domain)
         else:
             dyndns = False
     else:
@@ -364,8 +360,7 @@ def tools_postinstall(operation_logger, domain, password, ignore_dyndns=False,
         with open('/etc/ssowat/conf.json.persistent') as json_conf:
             ssowat_conf = json.loads(str(json_conf.read()))
     except ValueError as e:
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('ssowat_persistent_conf_read_error', error=str(e)))
+        raise YunohostError('ssowat_persistent_conf_read_error', error=str(e))
     except IOError:
         ssowat_conf = {}
 
@@ -378,8 +373,7 @@ def tools_postinstall(operation_logger, domain, password, ignore_dyndns=False,
         with open('/etc/ssowat/conf.json.persistent', 'w+') as f:
             json.dump(ssowat_conf, f, sort_keys=True, indent=4)
     except IOError as e:
-        raise MoulinetteError(errno.EPERM,
-                              m18n.n('ssowat_persistent_conf_write_error', error=str(e)))
+        raise YunohostError('ssowat_persistent_conf_write_error', error=str(e))
 
     os.system('chmod 644 /etc/ssowat/conf.json.persistent')
 
@@ -406,8 +400,7 @@ def tools_postinstall(operation_logger, domain, password, ignore_dyndns=False,
 
         if p.returncode != 0:
             logger.warning(out)
-            raise MoulinetteError(errno.EPERM,
-                                  m18n.n('yunohost_ca_creation_failed'))
+            raise YunohostError('yunohost_ca_creation_failed')
         else:
             logger.debug(out)
 
@@ -483,7 +476,7 @@ def tools_update(ignore_apps=False, ignore_packages=False):
         # Update APT cache
         logger.debug(m18n.n('updating_apt_cache'))
         if not cache.update():
-            raise MoulinetteError(errno.EPERM, m18n.n('update_cache_failed'))
+            raise YunohostError('update_cache_failed')
 
         cache.open(None)
         cache.upgrade(True)
@@ -502,7 +495,7 @@ def tools_update(ignore_apps=False, ignore_packages=False):
     if not ignore_apps:
         try:
             app_fetchlist()
-        except MoulinetteError:
+        except YunohostError:
             # FIXME : silent exception !?
             pass
 
@@ -633,7 +626,7 @@ def tools_diagnosis(auth, private=False):
     diagnosis['system'] = OrderedDict()
     try:
         disks = monitor_disk(units=['filesystem'], human_readable=True)
-    except (MoulinetteError, Fault) as e:
+    except (YunohostError, Fault) as e:
         logger.warning(m18n.n('diagnosis_monitor_disk_error', error=format(e)), exc_info=1)
     else:
         diagnosis['system']['disks'] = {}
@@ -649,7 +642,7 @@ def tools_diagnosis(auth, private=False):
 
     try:
         system = monitor_system(units=['cpu', 'memory'], human_readable=True)
-    except MoulinetteError as e:
+    except YunohostError as e:
         logger.warning(m18n.n('diagnosis_monitor_system_error', error=format(e)), exc_info=1)
     else:
         diagnosis['system']['memory'] = {
@@ -675,7 +668,7 @@ def tools_diagnosis(auth, private=False):
     # YNH Applications
     try:
         applications = app_list()['apps']
-    except MoulinetteError as e:
+    except YunohostError as e:
         diagnosis['applications'] = m18n.n('diagnosis_no_apps')
     else:
         diagnosis['applications'] = {}
@@ -807,7 +800,7 @@ def tools_migrations_list(pending=False, done=False):
 
     # Check for option conflict
     if pending and done:
-        raise MoulinetteError(errno.EINVAL, m18n.n("migrations_list_conflict_pending_done"))
+        raise YunohostError("migrations_list_conflict_pending_done")
 
     # Get all migrations
     migrations = _get_migrations_list()
@@ -864,7 +857,7 @@ def tools_migrations_migrate(target=None, skip=False, auto=False, accept_disclai
 
     # validate input, target must be "0" or a valid number
     elif target != 0 and target not in all_migration_numbers:
-        raise MoulinetteError(errno.EINVAL, m18n.n('migrations_bad_value_for_target', ", ".join(map(str, all_migration_numbers))))
+        raise YunohostError('migrations_bad_value_for_target', ", ".join(map(str, all_migration_numbers)))
 
     logger.debug(m18n.n('migrations_current_target', target))
 
@@ -1070,8 +1063,8 @@ def _load_migration(migration_file):
         import traceback
         traceback.print_exc()
 
-        raise MoulinetteError(errno.EINVAL, m18n.n('migrations_error_failed_to_load_migration',
-            number=number, name=name))
+        raise YunohostError('migrations_error_failed_to_load_migration',
+            number=number, name=name)
 
 def _skip_all_migrations():
     """
diff --git a/src/yunohost/user.py b/src/yunohost/user.py
index bb39dd58e..ea8dc30a9 100644
--- a/src/yunohost/user.py
+++ b/src/yunohost/user.py
@@ -27,14 +27,13 @@ import os
 import re
 import pwd
 import json
-import errno
 import crypt
 import random
 import string
 import subprocess
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 from yunohost.service import service_status
 from yunohost.log import is_unit_operation
@@ -71,8 +70,7 @@ def user_list(auth, fields=None):
             if attr in keys:
                 attrs.append(attr)
             else:
-                raise MoulinetteError(errno.EINVAL,
-                                      m18n.n('field_invalid', attr))
+                raise YunohostError('field_invalid', attr)
     else:
         attrs = ['uid', 'cn', 'mail', 'mailuserquota', 'loginShell']
 
@@ -130,7 +128,7 @@ def user_create(operation_logger, auth, username, firstname, lastname, mail, pas
     # Validate uniqueness of username in system users
     all_existing_usernames = {x.pw_name for x in pwd.getpwall()}
     if username in all_existing_usernames:
-        raise MoulinetteError(errno.EEXIST, m18n.n('system_username_exists'))
+        raise YunohostError('system_username_exists')
 
     main_domain = _get_maindomain()
     aliases = [
@@ -141,13 +139,11 @@ def user_create(operation_logger, auth, username, firstname, lastname, mail, pas
     ]
 
     if mail in aliases:
-        raise MoulinetteError(errno.EEXIST,m18n.n('mail_unavailable'))
+        raise YunohostError('mail_unavailable')
 
     # Check that the mail domain exists
     if mail.split("@")[1] not in domain_list(auth)['domains']:
-        raise MoulinetteError(errno.EINVAL,
-                              m18n.n('mail_domain_unknown',
-                                     domain=mail.split("@")[1]))
+        raise YunohostError('mail_domain_unknown', domain=mail.split("@")[1])
 
     operation_logger.start()
 
@@ -188,8 +184,7 @@ def user_create(operation_logger, auth, username, firstname, lastname, mail, pas
             with open('/etc/ssowat/conf.json.persistent') as json_conf:
                 ssowat_conf = json.loads(str(json_conf.read()))
         except ValueError as e:
-            raise MoulinetteError(errno.EINVAL,
-                                  m18n.n('ssowat_persistent_conf_read_error', error=e.strerror))
+            raise YunohostError('ssowat_persistent_conf_read_error', error=e.strerror)
         except IOError:
             ssowat_conf = {}
 
@@ -199,8 +194,7 @@ def user_create(operation_logger, auth, username, firstname, lastname, mail, pas
                 with open('/etc/ssowat/conf.json.persistent', 'w+') as f:
                     json.dump(ssowat_conf, f, sort_keys=True, indent=4)
             except IOError as e:
-                raise MoulinetteError(errno.EPERM,
-                                      m18n.n('ssowat_persistent_conf_write_error', error=e.strerror))
+                raise YunohostError('ssowat_persistent_conf_write_error', error=e.strerror)
 
     if auth.add('uid=%s,ou=users' % username, attr_dict):
         # Invalidate passwd to take user creation into account
@@ -226,7 +220,7 @@ def user_create(operation_logger, auth, username, firstname, lastname, mail, pas
 
             return {'fullname': fullname, 'username': username, 'mail': mail}
 
-    raise MoulinetteError(169, m18n.n('user_creation_failed'))
+    raise YunohostError('user_creation_failed')
 
 
 @is_unit_operation([('username', 'user')])
@@ -257,7 +251,7 @@ def user_delete(operation_logger, auth, username, purge=False):
             if purge:
                 subprocess.call(['rm', '-rf', '/home/{0}'.format(username)])
     else:
-        raise MoulinetteError(169, m18n.n('user_deletion_failed'))
+        raise YunohostError('user_deletion_failed')
 
     app_ssowatconf(auth)
 
@@ -296,7 +290,7 @@ def user_update(operation_logger, auth, username, firstname=None, lastname=None,
     # Populate user informations
     result = auth.search(base='ou=users,dc=yunohost,dc=org', filter='uid=' + username, attrs=attrs_to_fetch)
     if not result:
-        raise MoulinetteError(errno.EINVAL, m18n.n('user_unknown', user=username))
+        raise YunohostError('user_unknown', user=username)
     user = result[0]
 
     # Get modifications from arguments
@@ -327,11 +321,9 @@ def user_update(operation_logger, auth, username, firstname=None, lastname=None,
         ]
         auth.validate_uniqueness({'mail': mail})
         if mail[mail.find('@') + 1:] not in domains:
-            raise MoulinetteError(errno.EINVAL,
-                                  m18n.n('mail_domain_unknown',
-                                         domain=mail[mail.find('@') + 1:]))
+            raise YunohostError('mail_domain_unknown', domain=mail[mail.find('@') + 1:])
         if mail in aliases:
-            raise MoulinetteError(errno.EEXIST,m18n.n('mail_unavailable'))
+            raise YunohostError('mail_unavailable')
 
         del user['mail'][0]
         new_attr_dict['mail'] = [mail] + user['mail']
@@ -342,9 +334,7 @@ def user_update(operation_logger, auth, username, firstname=None, lastname=None,
         for mail in add_mailalias:
             auth.validate_uniqueness({'mail': mail})
             if mail[mail.find('@') + 1:] not in domains:
-                raise MoulinetteError(errno.EINVAL,
-                                      m18n.n('mail_domain_unknown',
-                                             domain=mail[mail.find('@') + 1:]))
+                raise YunohostError('mail_domain_unknown', domain=mail[mail.find('@') + 1:])
             user['mail'].append(mail)
         new_attr_dict['mail'] = user['mail']
 
@@ -355,8 +345,7 @@ def user_update(operation_logger, auth, username, firstname=None, lastname=None,
             if len(user['mail']) > 1 and mail in user['mail'][1:]:
                 user['mail'].remove(mail)
             else:
-                raise MoulinetteError(errno.EINVAL,
-                                      m18n.n('mail_alias_remove_failed', mail=mail))
+                raise YunohostError('mail_alias_remove_failed', mail=mail)
         new_attr_dict['mail'] = user['mail']
 
     if add_mailforward:
@@ -375,8 +364,7 @@ def user_update(operation_logger, auth, username, firstname=None, lastname=None,
             if len(user['maildrop']) > 1 and mail in user['maildrop'][1:]:
                 user['maildrop'].remove(mail)
             else:
-                raise MoulinetteError(errno.EINVAL,
-                                      m18n.n('mail_forward_remove_failed', mail=mail))
+                raise YunohostError('mail_forward_remove_failed', mail=mail)
         new_attr_dict['maildrop'] = user['maildrop']
 
     if mailbox_quota is not None:
@@ -389,7 +377,7 @@ def user_update(operation_logger, auth, username, firstname=None, lastname=None,
         app_ssowatconf(auth)
         return user_info(auth, username)
     else:
-        raise MoulinetteError(169, m18n.n('user_update_failed'))
+        raise YunohostError('user_update_failed')
 
 
 def user_info(auth, username):
@@ -414,7 +402,7 @@ def user_info(auth, username):
     if result:
         user = result[0]
     else:
-        raise MoulinetteError(errno.EINVAL, m18n.n('user_unknown', user=username))
+        raise YunohostError('user_unknown', user=username)
 
     result_dict = {
         'username': user['uid'][0],
@@ -470,7 +458,7 @@ def user_info(auth, username):
     if result:
         return result_dict
     else:
-        raise MoulinetteError(167, m18n.n('user_info_failed'))
+        raise YunohostError('user_info_failed')
 
 #
 # SSH subcategory
diff --git a/src/yunohost/utils/error.py b/src/yunohost/utils/error.py
new file mode 100644
index 000000000..74a63db7c
--- /dev/null
+++ b/src/yunohost/utils/error.py
@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+""" License
+
+    Copyright (C) 2018 YUNOHOST.ORG
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program; if not, see http://www.gnu.org/licenses
+
+"""
+
+from moulinette.core import MoulinetteError
+from moulinette import m18n
+
+class YunohostError(MoulinetteError):
+    """
+    Yunohost base exception
+    
+    The (only?) main difference with MoulinetteError being that keys
+    are translated via m18n.n (namespace) instead of m18n.g (global?)
+    """
+    def __init__(self, key, raw_msg=False, *args, **kwargs):
+        if raw_msg:
+            msg = key
+        else:
+            msg = m18n.n(key, *args, **kwargs)
+        super(YunohostError, self).__init__(msg, raw_msg=True)
+
diff --git a/src/yunohost/utils/password.py b/src/yunohost/utils/password.py
index 6e8f5ba0a..9cee56d53 100644
--- a/src/yunohost/utils/password.py
+++ b/src/yunohost/utils/password.py
@@ -81,17 +81,15 @@ class PasswordValidator(object):
         # on top (at least not the moulinette ones)
         # because the moulinette needs to be correctly initialized
         # as well as modules available in python's path.
-        import errno
         import logging
-        from moulinette import m18n
-        from moulinette.core import MoulinetteError
+        from yunohost.utils.error import YunohostError
         from moulinette.utils.log import getActionLogger
 
         logger = logging.getLogger('yunohost.utils.password')
 
         status, msg = self.validation_summary(password)
         if status == "error":
-            raise MoulinetteError(1, m18n.n(msg))
+            raise YunohostError(msg)
 
     def validation_summary(self, password):
         """
diff --git a/src/yunohost/utils/yunopaste.py b/src/yunohost/utils/yunopaste.py
index 2b53062d1..9226a7b12 100644
--- a/src/yunohost/utils/yunopaste.py
+++ b/src/yunohost/utils/yunopaste.py
@@ -2,9 +2,8 @@
 
 import requests
 import json
-import errno
 
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 
 def yunopaste(data):
 
@@ -13,17 +12,14 @@ def yunopaste(data):
     try:
         r = requests.post("%s/documents" % paste_server, data=data, timeout=30)
     except Exception as e:
-        raise MoulinetteError(errno.EIO,
-                              "Something wrong happened while trying to paste data on paste.yunohost.org : %s" % str(e))
+        raise YunohostError("Something wrong happened while trying to paste data on paste.yunohost.org : %s" % str(e), raw_msg=True)
 
     if r.status_code != 200:
-        raise MoulinetteError(errno.EIO,
-                              "Something wrong happened while trying to paste data on paste.yunohost.org : %s, %s" % (r.status_code, r.text))
+        raise YunohostError("Something wrong happened while trying to paste data on paste.yunohost.org : %s, %s" % (r.status_code, r.text), raw_msg=True)
 
     try:
         url = json.loads(r.text)["key"]
     except:
-        raise MoulinetteError(errno.EIO,
-                              "Uhoh, couldn't parse the answer from paste.yunohost.org : %s" % r.text)
+        raise YunohostError("Uhoh, couldn't parse the answer from paste.yunohost.org : %s" % r.text, raw_msg=True)
 
     return "%s/raw/%s" % (paste_server, url)