diff --git a/odoo/addons/base/tests/test_search.py b/odoo/addons/base/tests/test_search.py
index 53fa5dd455b..758176376ac 100644
--- a/odoo/addons/base/tests/test_search.py
+++ b/odoo/addons/base/tests/test_search.py
@@ -60,6 +60,80 @@ class test_search(TransactionCase):
         id_desc_active_desc = Partner.search([('name', 'like', 'test_search_order%'), '|', ('active', '=', True), ('active', '=', False)], order="id desc, active desc")
         self.assertEqual([e, ab, b, a, d, c], list(id_desc_active_desc), "Search with 'ID DESC, ACTIVE DESC' order failed.")
 
+        a.ref = "ref1"
+        c.ref = "ref2"
+        ids = (a | b | c).ids
+        for order, result in [
+            ('ref', a | c | b),
+            ('ref desc', b | c | a),
+            ('ref asc nulls first', b | a | c),
+            ('ref asc nulls last', a | c | b),
+            ('ref desc nulls first', b | c | a),
+            ('ref desc nulls last', c | a | b)
+        ]:
+            with self.subTest(order):
+                self.assertEqual(
+                    Partner.search([('id', 'in', ids)], order=order).mapped('name'),
+                    result.mapped('name'))
+
+        # sorting by an m2o should alias to the natural order of the m2o
+        self.patch_order('res.country', 'phone_code')
+        a.country_id, c.country_id = self.env['res.country'].create([{
+            'name': "Country 1",
+            'code': 'C1',
+            'phone_code': '01',
+        }, {
+            'name': 'Country 2',
+            'code': 'C2',
+            'phone_code': '02'
+        }])
+
+        for order, result in [
+            ('country_id', a | c | b),
+            ('country_id desc', b | c | a),
+            ('country_id asc nulls first', b | a | c),
+            ('country_id asc nulls last', a | c | b),
+            ('country_id desc nulls first', b | c | a),
+            ('country_id desc nulls last', c | a | b)
+        ]:
+            with self.subTest(order):
+                self.assertEqual(
+                    Partner.search([('id', 'in', ids)], order=order).mapped('name'),
+                    result.mapped('name'))
+
+        # NULLS applies to the m2o itself, not its sub-fields, so a null `phone_code`
+        # will sort normally (larger than non-null codes)
+        b.country_id = self.env['res.country'].create({'name': "Country X", 'code': 'C3'})
+
+        for order, result in [
+            ('country_id', a | c | b),
+            ('country_id desc', b | c | a),
+            ('country_id asc nulls first', a | c | b),
+            ('country_id asc nulls last', a | c | b),
+            ('country_id desc nulls first', b | c | a),
+            ('country_id desc nulls last', b | c | a)
+        ]:
+            with self.subTest(order):
+                self.assertEqual(
+                    Partner.search([('id', 'in', ids)], order=order).mapped('name'),
+                    result.mapped('name'))
+
+        # a field DESC should reverse the nested behaviour (and thus the inner
+        # NULLS clauses), but the outer NULLS clause still has no effect
+        self.patch_order('res.country', 'phone_code NULLS FIRST')
+        for order, result in [
+            ('country_id', b | a | c),
+            ('country_id desc', c | a | b),
+            ('country_id asc nulls first', b | a | c),
+            ('country_id asc nulls last', b | a | c),
+            ('country_id desc nulls first', c | a | b),
+            ('country_id desc nulls last', c | a | b)
+        ]:
+            with self.subTest(order):
+                self.assertEqual(
+                    Partner.search([('id', 'in', ids)], order=order).mapped('name'),
+                    result.mapped('name'))
+
     def test_10_inherits_m2order(self):
         Users = self.env['res.users']
 
diff --git a/odoo/models.py b/odoo/models.py
index 9764c2eae56..df3e7649116 100644
--- a/odoo/models.py
+++ b/odoo/models.py
@@ -61,7 +61,6 @@ from .tools import (
     get_lang, LastOrderedSet, lazy_classproperty, OrderedSet, ormcache,
     partition, populate, Query, ReversedIterable, split_every, unique,
 )
-from .tools.func import frame_codeinfo
 from .tools.lru import LRU
 from .tools.translate import _, _lt
 
@@ -69,7 +68,18 @@ _logger = logging.getLogger(__name__)
 _unlink = logging.getLogger(__name__ + '.unlink')
 
 regex_alphanumeric = re.compile(r'^[a-z0-9_]+$')
-regex_order = re.compile(r'^(\s*([a-z0-9:_]+|"[a-z0-9:_]+")(\.[a-z0-9]+)?(\s+(desc|asc))?\s*(,|$))+(?<!,)$', re.I)
+regex_order = re.compile(r'''
+    ^
+    (\s*
+        ((?P<field>[a-z0-9:_]+|"[a-z0-9:_]+")(\.(?P<property>[a-z0-9_]+))?)
+        (\s+(?P<direction>desc|asc))?
+        (\s+(?P<nulls>nulls\ first|nulls\ last))?
+        \s*
+        (,|$)
+    )+
+    (?<!,)
+    $
+''', re.IGNORECASE | re.VERBOSE)
 regex_object_name = re.compile(r'^[a-z0-9_.]+$')
 regex_pg_name = re.compile(r'^[a-z_][a-z0-9_$]*$', re.I)
 regex_field_agg = re.compile(r'(\w+)(?::(\w+)(?:\((\w+)\))?)?')
@@ -4573,17 +4583,17 @@ class BaseModel(metaclass=MetaModel):
 
         order_by_elements = []
         for order_part in order_spec.split(','):
-            order_split = order_part.strip().split(' ')
-            order_field = order_split[0].strip()
-
-            property_name = None
-            if "." in order_field:
-                order_field, property_name = order_field.split('.', 1)
+            order_match = regex_order.match(order_part)
+            order_field = order_match['field']
+            property_name = order_match['property']
+            if property_name:
                 check_property_field_value_name(property_name)
-
-            order_direction = order_split[1].strip().upper() if len(order_split) == 2 else ''
+            order_direction = (order_match['direction'] or '').upper()
+            order_nulls = (order_match['nulls'] or '').upper()
             if reverse_direction:
                 order_direction = 'ASC' if order_direction == 'DESC' else 'DESC'
+                if order_nulls:
+                    order_nulls = 'NULLS LAST' if order_nulls == 'NULLS FIRST' else 'NULLS FIRST'
             do_reverse = order_direction == 'DESC'
 
             field = self._fields.get(order_field)
@@ -4591,12 +4601,18 @@ class BaseModel(metaclass=MetaModel):
                 raise ValueError("Invalid field %r on model %r" % (order_field, self._name))
 
             if order_field == 'id':
-                order_by_elements.append('"%s"."%s" %s' % (alias, order_field, order_direction))
+                order_by_elements.append(f'"{alias}"."{order_field}" {order_direction} {order_nulls}')
             else:
                 if field.inherited:
                     field = field.base_field
                 if field.store and field.type == 'many2one':
                     key = (field.model_name, field.comodel_name, order_field)
+                    if order_nulls:
+                        qname = self._inherits_join_calc(alias, order_field, query)
+                        if order_nulls == 'NULLS LAST':
+                            order_by_elements.append(f"{qname} IS NULL")
+                        elif order_nulls == 'NULLS FIRST':
+                            order_by_elements.append(f"{qname} IS NOT NULL")
                     if key not in seen:
                         seen.add(key)
                         order_by_elements += self._generate_m2o_order_by(alias, order_field, query, do_reverse, seen)
@@ -4606,7 +4622,7 @@ class BaseModel(metaclass=MetaModel):
                         qualifield_name = "COALESCE(%s, false)" % qualifield_name
                     elif field.type == 'properties' and property_name:
                         qualifield_name = f"({qualifield_name} -> '{property_name}')"
-                    order_by_elements.append("%s %s" % (qualifield_name, order_direction))
+                    order_by_elements.append(f"{qualifield_name} {order_direction} {order_nulls}")
                 else:
                     _logger.warning("Model %r cannot be sorted on field %r (not a column)", self._name, order_field)
                     continue  # ignore non-readable or "non-joinable" fields