diff --git a/fs_attachment/README.rst b/fs_attachment/README.rst
index be909f69c9..3bc5efba28 100644
--- a/fs_attachment/README.rst
+++ b/fs_attachment/README.rst
@@ -160,6 +160,18 @@ configure the way attachments will be stored in the filesystem.
   - application/javascript are stored in database whatever their size
   - text/css are stored in database whatever their size
 
+  A key can also be a ``<model>.<field>`` pair to force the storage in
+  database of the attachments of a specific binary field, whatever their
+  mimetype. It's useful for fields like the menu icons, that are read on
+  every page load, without having to keep all the images in database:
+
+     {"image/": 51200, "application/javascript": 0, "text/css": 0,
+     "ir.ui.menu.web_icon_data": 0}
+
+  A field rule is checked before the mimetype rules: if the attachment
+  matches it and is within its limit, it is stored in database,
+  otherwise the mimetype rules apply.
+
   This option is only available on the filesystem storage that is used
   as default for attachments.
 
diff --git a/fs_attachment/models/fs_storage.py b/fs_attachment/models/fs_storage.py
index fdffe76e15..35be667634 100644
--- a/fs_attachment/models/fs_storage.py
+++ b/fs_attachment/models/fs_storage.py
@@ -66,7 +66,10 @@ class FsStorage(models.Model):
         "* images mimetypes (image/png, image/jpeg, ...) below 50KB are stored "
         "in database\n"
         "* application/javascript are stored in database whatever their size \n"
-        "* text/css are stored in database whatever their size",
+        "* text/css are stored in database whatever their size\n"
+        "A key can also be a '<model>.<field>' pair (e.g. "
+        "'ir.ui.menu.web_icon_data') to force the storage in database of the "
+        "attachments of a specific binary field, whatever their mimetype.",
         default=lambda self: self._default_force_db_for_default_attachment_rules,
     )
     use_filename_obfuscation = fields.Boolean(
diff --git a/fs_attachment/models/ir_attachment.py b/fs_attachment/models/ir_attachment.py
index 3227f7c7c7..5b2ccafa0c 100644
--- a/fs_attachment/models/ir_attachment.py
+++ b/fs_attachment/models/ir_attachment.py
@@ -152,6 +152,27 @@ def _get_storage_force_db_config(self):
             self._storage()
         )
 
+    def _get_storage_force_db_rules(self):
+        """Split the force db config into mimetype rules and field rules
+
+        A key containing a "/" is the beginning of a mimetype. A key without
+        "/" but with a "." is a ``<model>.<field>`` pair (e.g.
+        ``ir.ui.menu.web_icon_data``).
+
+        :return: a tuple ``(mimetype_rules, field_rules)`` where
+          ``mimetype_rules`` is a dict ``{mimetype_key: limit}`` and
+          ``field_rules`` a dict ``{(res_model, res_field): limit}``
+        """
+        mimetype_rules = {}
+        field_rules = {}
+        for key, limit in self._get_storage_force_db_config().items():
+            if "/" not in key and "." in key:
+                res_model, res_field = key.rsplit(".", 1)
+                field_rules[(res_model, res_field)] = limit
+            else:
+                mimetype_rules[key] = limit
+        return mimetype_rules, field_rules
+
     def _store_in_db_instead_of_object_storage_domain(self):
         """Return a domain for attachments that must be forced to DB
 
@@ -165,13 +186,18 @@ def _store_in_db_instead_of_object_storage_domain(self):
         ``_store_in_db_instead_of_object_storage``.
         """
         domain = []
-        storage_config = self._get_storage_force_db_config()
-        for mimetype_key, limit in storage_config.items():
+        mimetype_rules, field_rules = self._get_storage_force_db_rules()
+        for mimetype_key, limit in mimetype_rules.items():
             part = [("mimetype", "=like", f"{mimetype_key}%")]
             if limit:
                 part = Domain.AND([part, [("file_size", "<=", limit)]])
             # OR simplifies to [(1, '=', 1)] if a domain being OR'ed is empty
             domain = Domain.OR([domain, part]) if domain else part
+        for (res_model, res_field), limit in field_rules.items():
+            part = [("res_model", "=", res_model), ("res_field", "=", res_field)]
+            if limit:
+                part = Domain.AND([part, [("file_size", "<=", limit)]])
+            domain = Domain.OR([domain, part]) if domain else part
         return domain
 
     def _store_in_db_instead_of_object_storage(self, data, mimetype):
@@ -204,6 +230,16 @@ def _store_in_db_instead_of_object_storage(self, data, mimetype):
         value is the limit in size below which attachments are kept in DB.
         0 means no limit.
 
+        A key can also be a ``<model>.<field>`` pair to force the storage in
+        DB of the attachments of a specific binary field, whatever their
+        mimetype, for instance::
+
+            {"image/": 51200, "ir.ui.menu.web_icon_data": 0}
+
+        A field rule is checked before the mimetype rules: if the attachment
+        matches it and is within its limit, it is stored in DB, otherwise the
+        mimetype rules apply.
+
         These limits are applied only if the storage is the default one for
         attachments (see ``_storage``).
 
@@ -214,8 +250,16 @@ def _store_in_db_instead_of_object_storage(self, data, mimetype):
         """
         if self._is_storage_disabled():
             return True
-        storage_config = self._get_storage_force_db_config()
-        for mimetype_key, limit in storage_config.items():
+        mimetype_rules, field_rules = self._get_storage_force_db_rules()
+        field_key = (
+            self.env.context.get("attachment_res_model"),
+            self.env.context.get("attachment_res_field"),
+        )
+        if field_key in field_rules:
+            limit = field_rules[field_key]
+            if not limit or len(data) <= limit:
+                return True
+        for mimetype_key, limit in mimetype_rules.items():
             if mimetype.startswith(mimetype_key):
                 if not limit:
                     return True
diff --git a/fs_attachment/readme/USAGE.md b/fs_attachment/readme/USAGE.md
index 6283ddb40d..59bfda6828 100644
--- a/fs_attachment/readme/USAGE.md
+++ b/fs_attachment/readme/USAGE.md
@@ -70,6 +70,18 @@ configure the way attachments will be stored in the filesystem.
   - application/javascript are stored in database whatever their size
   - text/css are stored in database whatever their size
 
+  A key can also be a `<model>.<field>` pair to force the storage in
+  database of the attachments of a specific binary field, whatever their
+  mimetype. It's useful for fields like the menu icons, that are read on
+  every page load, without having to keep all the images in database:
+
+  > {"image/": 51200, "application/javascript": 0, "text/css": 0,
+  > "ir.ui.menu.web_icon_data": 0}
+
+  A field rule is checked before the mimetype rules: if the attachment
+  matches it and is within its limit, it is stored in database,
+  otherwise the mimetype rules apply.
+
   This option is only available on the filesystem storage that is used
   as default for attachments.
 
diff --git a/fs_attachment/readme/newsfragments/force_db_field.feature b/fs_attachment/readme/newsfragments/force_db_field.feature
new file mode 100644
index 0000000000..c59ecb4200
--- /dev/null
+++ b/fs_attachment/readme/newsfragments/force_db_field.feature
@@ -0,0 +1,3 @@
+Allow `<model>.<field>` keys in `force_db_for_default_attachment_rules` to keep
+the attachments of a specific binary field (e.g. `ir.ui.menu.web_icon_data`) in
+the database whatever their mimetype.
diff --git a/fs_attachment/static/description/index.html b/fs_attachment/static/description/index.html
index 561f035b25..3c2b1a9cf1 100644
--- a/fs_attachment/static/description/index.html
+++ b/fs_attachment/static/description/index.html
@@ -3,7 +3,7 @@
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 <meta name="generator" content="Docutils: https://docutils.sourceforge.io/" />
-<title>Base Attachment Object Store</title>
+<title>README.rst</title>
 <style type="text/css">
 
 /*
@@ -526,6 +526,17 @@ <h3><a class="toc-backref" href="#toc-entry-2">Configuration</a></h3>
 <li>application/javascript are stored in database whatever their size</li>
 <li>text/css are stored in database whatever their size</li>
 </ul>
+<p>A key can also be a <tt class="docutils literal"><span class="pre">&lt;model&gt;.&lt;field&gt;</span></tt> pair to force the storage in
+database of the attachments of a specific binary field, whatever their
+mimetype. It’s useful for fields like the menu icons, that are read on
+every page load, without having to keep all the images in database:</p>
+<blockquote>
+<p>{“image/”: 51200, “application/javascript”: 0, “text/css”: 0,
+“ir.ui.menu.web_icon_data”: 0}</p>
+</blockquote>
+<p>A field rule is checked before the mimetype rules: if the attachment
+matches it and is within its limit, it is stored in database,
+otherwise the mimetype rules apply.</p>
 <p>This option is only available on the filesystem storage that is used
 as default for attachments.</p>
 </li>
diff --git a/fs_attachment/tests/test_fs_attachment.py b/fs_attachment/tests/test_fs_attachment.py
index 42dd4cd734..6dc6313427 100644
--- a/fs_attachment/tests/test_fs_attachment.py
+++ b/fs_attachment/tests/test_fs_attachment.py
@@ -1,5 +1,6 @@
 # Copyright 2023 ACSONE SA/NV (http://acsone.eu).
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+import base64
 import os
 from pathlib import Path
 from unittest import mock
@@ -340,6 +341,59 @@ def test_force_attachment_in_db_rules(self):
         self.assertEqual(attachment.db_datas, b"content")
         self.assertEqual(attachment.mimetype, "text/plain")
 
+    def _create_menu_with_icon(self):
+        icon = b'<svg xmlns="http://www.w3.org/2000/svg"><rect/></svg>'
+        menu = self.env["ir.ui.menu"].create(
+            {"name": "Test Menu", "web_icon_data": base64.b64encode(icon)}
+        )
+        self.env.flush_all()
+        attachment = self.ir_attachment_model.search(
+            [
+                ("res_model", "=", "ir.ui.menu"),
+                ("res_field", "=", "web_icon_data"),
+                ("res_id", "=", menu.id),
+            ]
+        )
+        self.assertEqual(attachment.mimetype, "image/svg+xml")
+        return icon, attachment
+
+    def test_force_attachment_in_db_rules_field(self):
+        self.temp_backend.use_as_default_for_attachments = True
+        # images are kept in db below 10 bytes only, but menu icons always
+        self.temp_backend.force_db_for_default_attachment_rules = (
+            '{"image/": 10, "ir.ui.menu.web_icon_data": 0}'
+        )
+        icon, attachment = self._create_menu_with_icon()
+        self.assertFalse(attachment.store_fname)
+        self.assertEqual(attachment.db_datas, icon)
+        # the same image not linked to the field goes to the storage
+        other = self.ir_attachment_model.create({"name": "icon.svg", "raw": icon})
+        self.env.flush_all()
+        self.assertTrue(other.store_fname.startswith("tmp_dir://"))
+        self.assertFalse(other.db_datas)
+
+    def test_force_attachment_in_db_rules_field_limit(self):
+        self.temp_backend.use_as_default_for_attachments = True
+        # the icon is above the field limit and no mimetype rule matches
+        self.temp_backend.force_db_for_default_attachment_rules = (
+            '{"ir.ui.menu.web_icon_data": 10}'
+        )
+        _icon, attachment = self._create_menu_with_icon()
+        self.assertTrue(attachment.store_fname.startswith("tmp_dir://"))
+        self.assertFalse(attachment.db_datas)
+
+    def test_force_storage_to_db_field(self):
+        self.temp_backend.use_as_default_for_attachments = True
+        self.temp_backend.force_db_for_default_attachment_rules = "{}"
+        icon, attachment = self._create_menu_with_icon()
+        self.assertTrue(attachment.store_fname.startswith("tmp_dir://"))
+        self.temp_backend.force_db_for_default_attachment_rules = (
+            '{"ir.ui.menu.web_icon_data": 0}'
+        )
+        attachment.force_storage_to_db_for_special_fields()
+        self.assertFalse(attachment.store_fname)
+        self.assertEqual(attachment.db_datas, icon)
+
     def test_force_storage_to_db(self):
         self.temp_backend.use_as_default_for_attachments = True
         attachment = self.ir_attachment_model.create(
@@ -552,7 +606,12 @@ def test_store_in_db_instead_of_object_storage_domain(self):
         self.patch(
             type(IrAttachment),
             "_get_storage_force_db_config",
-            lambda self: {"text/plain": 0, "image/png": 100},
+            lambda self: {
+                "text/plain": 0,
+                "image/png": 100,
+                "ir.ui.menu.web_icon_data": 0,
+                "res.partner.image_1920": 200,
+            },
         )
         self.assertEqual(
             self.env["ir.attachment"]._store_in_db_instead_of_object_storage_domain(),
@@ -565,6 +624,19 @@ def test_store_in_db_instead_of_object_storage_domain(self):
                             Domain("file_size", "<=", 100),
                         ]
                     ),
+                    Domain.AND(
+                        [
+                            Domain("res_model", "=", "ir.ui.menu"),
+                            Domain("res_field", "=", "web_icon_data"),
+                        ]
+                    ),
+                    Domain.AND(
+                        [
+                            Domain("res_model", "=", "res.partner"),
+                            Domain("res_field", "=", "image_1920"),
+                            Domain("file_size", "<=", 200),
+                        ]
+                    ),
                 ]
             ),
         )