diff --git a/qutebrowser/browser/webengine/darkmode.py b/qutebrowser/browser/webengine/darkmode.py
index 16564269a..14bd05903 100644
--- a/qutebrowser/browser/webengine/darkmode.py
+++ b/qutebrowser/browser/webengine/darkmode.py
@@ -332,7 +332,7 @@ _PREFERRED_COLOR_SCHEME_DEFINITIONS = {
 }
 
 
-def _variant() -> Variant:
+def _variant(versions: version.WebEngineVersions) -> Variant:
     """Get the dark mode variant based on the underlying Qt version."""
     env_var = os.environ.get('QUTE_DARKMODE_VARIANT')
     if env_var is not None:
@@ -341,7 +341,6 @@ def _variant() -> Variant:
         except KeyError:
             log.init.warning(f"Ignoring invalid QUTE_DARKMODE_VARIANT={env_var}")
 
-    versions = version.qtwebengine_versions(avoid_init=True)
     if (versions.webengine == utils.VersionNumber(5, 15, 2) and
             versions.chromium is not None and
             versions.chromium.startswith('87.')):
@@ -362,7 +361,11 @@ def _variant() -> Variant:
     raise utils.Unreachable(versions.webengine)
 
 
-def settings(special_flags: Sequence[str]) -> Mapping[str, Sequence[Tuple[str, str]]]:
+def settings(
+        *,
+        versions: version.WebEngineVersions,
+        special_flags: Sequence[str],
+) -> Mapping[str, Sequence[Tuple[str, str]]]:
     """Get necessary blink settings to configure dark mode for QtWebEngine.
 
     Args:
@@ -373,7 +376,7 @@ def settings(special_flags: Sequence[str]) -> Mapping[str, Sequence[Tuple[str, s
         to a sequence of tuples, each tuple being a key/value pair to pass to that
         setting.
     """
-    variant = _variant()
+    variant = _variant(versions)
     result: Mapping[str, List[Tuple[str, str]]] = collections.defaultdict(list)
 
     blink_settings_flag = f'--{_BLINK_SETTINGS}='
diff --git a/qutebrowser/config/qtargs.py b/qutebrowser/config/qtargs.py
index c86579255..7f971e2a0 100644
--- a/qutebrowser/config/qtargs.py
+++ b/qutebrowser/config/qtargs.py
@@ -26,7 +26,7 @@ from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple
 
 from qutebrowser.config import config
 from qutebrowser.misc import objects
-from qutebrowser.utils import usertypes, qtutils, utils, log
+from qutebrowser.utils import usertypes, qtutils, utils, log, version
 
 
 _ENABLE_FEATURES = '--enable-features='
@@ -67,11 +67,13 @@ def qt_args(namespace: argparse.Namespace) -> List[str]:
 
 
 def _qtwebengine_features(
+        versions: version.WebEngineVersions,
         special_flags: Sequence[str],
 ) -> Tuple[Sequence[str], Sequence[str]]:
     """Get a tuple of --enable-features/--disable-features flags for QtWebEngine.
 
     Args:
+        versions: The WebEngineVersions to get flags for.
         special_flags: Existing flags passed via the commandline.
     """
     enabled_features = []
@@ -89,7 +91,7 @@ def _qtwebengine_features(
         else:
             raise utils.Unreachable(flag)
 
-    if qtutils.version_check('5.15', compiled=False) and utils.is_linux:
+    if versions.webengine >= utils.VersionNumber(5, 15, 1) and utils.is_linux:
         # Enable WebRTC PipeWire for screen capturing on Wayland.
         #
         # This is disabled in Chromium by default because of the "dialog hell":
@@ -101,8 +103,7 @@ def _qtwebengine_features(
         #
         # In theory this would be supported with Qt 5.13 already, but
         # QtWebEngine only started picking up PipeWire correctly with Qt
-        # 5.15.1. Checking for 5.15 here to pick up Archlinux' patched package
-        # as well.
+        # 5.15.1.
         #
         # This only should be enabled on Wayland, but it's too early to check
         # that, as we don't have a QApplication available at this point. Thus,
@@ -125,20 +126,18 @@ def _qtwebengine_features(
         if config.val.scrolling.bar == 'overlay':
             enabled_features.append('OverlayScrollbar')
 
-    if (qtutils.version_check('5.14', compiled=False) and
+    if (versions.webengine >= utils.VersionNumber(5, 14) and
             config.val.content.headers.referer == 'same-domain'):
         # Handling of reduced-referrer-granularity in Chromium 76+
         # https://chromium-review.googlesource.com/c/chromium/src/+/1572699
         #
         # Note that this is removed entirely (and apparently the default) starting with
-        # Chromium 89 (Qt 5.15.x or 6.x):
+        # Chromium 89 (presumably arriving with Qt 6.2):
         # https://chromium-review.googlesource.com/c/chromium/src/+/2545444
         enabled_features.append('ReducedReferrerGranularity')
 
-    if qtutils.version_check('5.15.2', compiled=False, exact=True):
+    if versions.webengine == utils.VersionNumber(5, 15, 2):
         # WORKAROUND for https://bugreports.qt.io/browse/QTBUG-89740
-        # FIXME Not needed anymore with QtWebEngne 5.15.3 (or Qt 6), but we'll probably
-        # have no way to detect that...
         disabled_features.append('InstalledApp')
 
     return (enabled_features, disabled_features)
@@ -149,10 +148,11 @@ def _qtwebengine_args(
         special_flags: Sequence[str],
 ) -> Iterator[str]:
     """Get the QtWebEngine arguments to use based on the config."""
-    is_qt_514 = (qtutils.version_check('5.14', compiled=False) and
-                 not qtutils.version_check('5.15', compiled=False))
+    versions = version.qtwebengine_versions(avoid_init=True)
 
-    if is_qt_514:
+    qt_514_ver = utils.VersionNumber(5, 14)
+    qt_515_ver = utils.VersionNumber(5, 15)
+    if qt_514_ver <= versions.webengine < qt_515_ver:
         # WORKAROUND for https://bugreports.qt.io/browse/QTBUG-82105
         yield '--disable-shared-workers'
 
@@ -160,7 +160,7 @@ def _qtwebengine_args(
     # https://codereview.qt-project.org/c/qt/qtwebengine/+/256786
     # also see:
     # https://codereview.qt-project.org/c/qt/qtwebengine-chromium/+/265753
-    if qtutils.version_check('5.12.3', compiled=False):
+    if versions.webengine >= utils.VersionNumber(5, 12, 3):
         if 'stack' in namespace.debug_flags:
             # Only actually available in Qt 5.12.5, but let's save another
             # check, as passing the option won't hurt.
@@ -177,22 +177,26 @@ def _qtwebengine_args(
         yield '--renderer-startup-dialog'
 
     from qutebrowser.browser.webengine import darkmode
-    for switch_name, values in darkmode.settings(special_flags).items():
+    darkmode_settings = darkmode.settings(
+        versions=versions,
+        special_flags=special_flags,
+    )
+    for switch_name, values in darkmode_settings.items():
         # If we need to use other switches (say, --enable-features), we might need to
         # refactor this so values still get combined with existing ones.
         assert switch_name in ['dark-mode-settings', 'blink-settings'], switch_name
         yield f'--{switch_name}=' + ','.join(f'{k}={v}' for k, v in values)
 
-    enabled_features, disabled_features = _qtwebengine_features(special_flags)
+    enabled_features, disabled_features = _qtwebengine_features(versions, special_flags)
     if enabled_features:
         yield _ENABLE_FEATURES + ','.join(enabled_features)
     if disabled_features:
         yield _DISABLE_FEATURES + ','.join(disabled_features)
 
-    yield from _qtwebengine_settings_args()
+    yield from _qtwebengine_settings_args(versions)
 
 
-def _qtwebengine_settings_args() -> Iterator[str]:
+def _qtwebengine_settings_args(versions: version.WebEngineVersions) -> Iterator[str]:
     settings: Dict[str, Dict[Any, Optional[str]]] = {
         'qt.force_software_rendering': {
             'software-opengl': None,
@@ -230,9 +234,9 @@ def _qtwebengine_settings_args() -> Iterator[str]:
             'always': None,
         }
     }
+    qt_514_ver = utils.VersionNumber(5, 14)
 
-    if (qtutils.version_check('5.14', compiled=False) and
-            not qtutils.version_check('5.15.2', compiled=False)):
+    if qt_514_ver <= versions.webengine < utils.VersionNumber(5, 15, 2):
         # In Qt 5.14 to 5.15.1, `--force-dark-mode` is used to set the
         # preferred colorscheme. In Qt 5.15.2, this is handled by a
         # blink-setting in browser/webengine/darkmode.py instead.
@@ -243,17 +247,17 @@ def _qtwebengine_settings_args() -> Iterator[str]:
         }
 
     referrer_setting = settings['content.headers.referer']
-    if qtutils.version_check('5.14', compiled=False):
+    if versions.webengine >= qt_514_ver:
         # Starting with Qt 5.14, this is handled via --enable-features
         referrer_setting['same-domain'] = None
     else:
         referrer_setting['same-domain'] = '--reduced-referrer-granularity'
 
-    can_override_referer = (
-        qtutils.version_check('5.12.4', compiled=False) and
-        not qtutils.version_check('5.13.0', compiled=False, exact=True)
-    )
     # WORKAROUND for https://bugreports.qt.io/browse/QTBUG-60203
+    can_override_referer = (
+        versions.webengine >= utils.VersionNumber(5, 12, 4) and
+        versions.webengine != utils.VersionNumber(5, 13)
+    )
     referrer_setting['never'] = None if can_override_referer else '--no-referrers'
 
     for setting, args in sorted(settings.items()):
diff --git a/tests/unit/browser/webengine/test_darkmode.py b/tests/unit/browser/webengine/test_darkmode.py
index 65c6665c5..3f4a9bca3 100644
--- a/tests/unit/browser/webengine/test_darkmode.py
+++ b/tests/unit/browser/webengine/test_darkmode.py
@@ -33,13 +33,12 @@ def patch_backend(monkeypatch):
 
 
 @pytest.fixture
-def gentoo_version_patch(monkeypatch):
-    versions = version.WebEngineVersions(
+def gentoo_versions():
+    return version.WebEngineVersions(
         webengine=utils.VersionNumber(5, 15, 2),
         chromium='87.0.4280.144',
         source='faked',
     )
-    monkeypatch.setattr(version, 'qtwebengine_versions', lambda avoid_init: versions)
 
 
 @pytest.mark.parametrize('value, webengine_version, expected', [
@@ -76,18 +75,20 @@ def gentoo_version_patch(monkeypatch):
     ("light", "6.0.0", [("preferredColorScheme", "1")]),
 ])
 @testutils.qt514
-def test_colorscheme(config_stub, monkeypatch, value, webengine_version, expected):
+def test_colorscheme(config_stub, value, webengine_version, expected):
     versions = version.WebEngineVersions.from_pyqt(webengine_version)
-    monkeypatch.setattr(version, 'qtwebengine_versions', lambda avoid_init: versions)
     if value is not None:
         config_stub.val.colors.webpage.preferred_color_scheme = value
-    assert darkmode.settings([])['blink-settings'] == expected
+
+    darkmode_settings = darkmode.settings(versions=versions, special_flags=[])
+    assert darkmode_settings['blink-settings'] == expected
 
 
 @testutils.qt514
-def test_colorscheme_gentoo_workaround(config_stub, gentoo_version_patch):
+def test_colorscheme_gentoo_workaround(config_stub, gentoo_versions):
     config_stub.val.colors.webpage.preferred_color_scheme = "dark"
-    assert darkmode.settings([])['blink-settings'] == [("preferredColorScheme", "0")]
+    darkmode_settings = darkmode.settings(versions=gentoo_versions, special_flags=[])
+    assert darkmode_settings['blink-settings'] == [("preferredColorScheme", "0")]
 
 
 @pytest.mark.parametrize('settings, expected', [
@@ -106,17 +107,17 @@ def test_colorscheme_gentoo_workaround(config_stub, gentoo_version_patch):
         ],
     ),
 ])
-def test_basics(config_stub, monkeypatch, settings, expected):
+def test_basics(config_stub, settings, expected):
     for k, v in settings.items():
         config_stub.set_obj('colors.webpage.darkmode.' + k, v)
 
-    # Using Qt 5.15.1 because it has the least special cases.
-    monkeypatch.setattr(darkmode, '_variant', lambda: darkmode.Variant.qt_515_1)
-
     if expected:
         expected.append(('darkModeImagePolicy', '2'))
 
-    assert darkmode.settings([])['blink-settings'] == expected
+    # Using Qt 5.15.1 because it has the least special cases.
+    versions = version.WebEngineVersions.from_pyqt('5.15.1')
+    darkmode_settings = darkmode.settings(versions=versions, special_flags=[])
+    assert darkmode_settings['blink-settings'] == expected
 
 
 QT_514_SETTINGS = {'blink-settings': [
@@ -171,10 +172,7 @@ QT_515_3_SETTINGS = {
     ('5.15.2', QT_515_2_SETTINGS),
     ('5.15.3', QT_515_3_SETTINGS),
 ])
-def test_qt_version_differences(config_stub, monkeypatch, qversion, expected):
-    versions = version.WebEngineVersions.from_pyqt(qversion)
-    monkeypatch.setattr(version, 'qtwebengine_versions', lambda avoid_init: versions)
-
+def test_qt_version_differences(config_stub, qversion, expected):
     settings = {
         'enabled': True,
         'algorithm': 'brightness-rgb',
@@ -183,7 +181,9 @@ def test_qt_version_differences(config_stub, monkeypatch, qversion, expected):
     for k, v in settings.items():
         config_stub.set_obj('colors.webpage.darkmode.' + k, v)
 
-    assert darkmode.settings([]) == expected
+    versions = version.WebEngineVersions.from_pyqt(qversion)
+    darkmode_settings = darkmode.settings(versions=versions, special_flags=[])
+    assert darkmode_settings == expected
 
 
 @testutils.qt514
@@ -203,10 +203,9 @@ def test_qt_version_differences(config_stub, monkeypatch, qversion, expected):
     ('grayscale.images', 0.5,
      'ImageGrayscale', '0.5'),
 ])
-def test_customization(config_stub, monkeypatch, setting, value, exp_key, exp_val):
+def test_customization(config_stub, setting, value, exp_key, exp_val):
     config_stub.val.colors.webpage.darkmode.enabled = True
     config_stub.set_obj('colors.webpage.darkmode.' + setting, value)
-    monkeypatch.setattr(darkmode, '_variant', lambda: darkmode.Variant.qt_515_1)
 
     expected = []
     expected.append(('darkModeEnabled', 'true'))
@@ -214,7 +213,9 @@ def test_customization(config_stub, monkeypatch, setting, value, exp_key, exp_va
         expected.append(('darkModeImagePolicy', '2'))
     expected.append(('darkMode' + exp_key, exp_val))
 
-    assert darkmode.settings([])['blink-settings'] == expected
+    versions = version.WebEngineVersions.from_pyqt('5.15.1')
+    darkmode_settings = darkmode.settings(versions=versions, special_flags=[])
+    assert darkmode_settings['blink-settings'] == expected
 
 
 @pytest.mark.parametrize('webengine_version, expected', [
@@ -226,14 +227,13 @@ def test_customization(config_stub, monkeypatch, setting, value, exp_key, exp_va
     ('5.15.3', darkmode.Variant.qt_515_3),
     ('6.0.0', darkmode.Variant.qt_515_3),
 ])
-def test_variant(monkeypatch, webengine_version, expected):
+def test_variant(webengine_version, expected):
     versions = version.WebEngineVersions.from_pyqt(webengine_version)
-    monkeypatch.setattr(version, 'qtwebengine_versions', lambda avoid_init: versions)
-    assert darkmode._variant() == expected
+    assert darkmode._variant(versions) == expected
 
 
-def test_variant_gentoo_workaround(gentoo_version_patch):
-    assert darkmode._variant() == darkmode.Variant.qt_515_3
+def test_variant_gentoo_workaround(gentoo_versions):
+    assert darkmode._variant(gentoo_versions) == darkmode.Variant.qt_515_3
 
 
 @pytest.mark.parametrize('value, is_valid, expected', [
@@ -242,24 +242,22 @@ def test_variant_gentoo_workaround(gentoo_version_patch):
 ])
 def test_variant_override(monkeypatch, caplog, value, is_valid, expected):
     versions = version.WebEngineVersions.from_pyqt('5.15.0')
-    monkeypatch.setattr(version, 'qtwebengine_versions', lambda avoid_init: versions)
     monkeypatch.setenv('QUTE_DARKMODE_VARIANT', value)
 
     with caplog.at_level(logging.WARNING):
-        assert darkmode._variant() == expected
+        assert darkmode._variant(versions) == expected
 
     log_msg = 'Ignoring invalid QUTE_DARKMODE_VARIANT=invalid_value'
     assert (log_msg in caplog.messages) != is_valid
 
 
-def test_broken_smart_images_policy(config_stub, monkeypatch, caplog):
+def test_broken_smart_images_policy(config_stub, caplog):
     config_stub.val.colors.webpage.darkmode.enabled = True
     config_stub.val.colors.webpage.darkmode.policy.images = 'smart'
     versions = version.WebEngineVersions.from_pyqt('5.15.0')
-    monkeypatch.setattr(version, 'qtwebengine_versions', lambda avoid_init: versions)
 
     with caplog.at_level(logging.WARNING):
-        settings = darkmode.settings([])['blink-settings']
+        darkmode_settings = darkmode.settings(versions=versions, special_flags=[])
 
     assert caplog.messages[-1] == (
         'Ignoring colors.webpage.darkmode.policy.images = smart because of '
@@ -269,7 +267,7 @@ def test_broken_smart_images_policy(config_stub, monkeypatch, caplog):
         [('darkModeEnabled', 'true')],  # Qt 5.15
         [('darkMode', '4')],  # Qt 5.14
     ]
-    assert settings in expected
+    assert darkmode_settings['blink-settings'] in expected
 
 
 @pytest.mark.parametrize('flag, expected', [
@@ -278,11 +276,10 @@ def test_broken_smart_images_policy(config_stub, monkeypatch, caplog):
     ('--blink-settings=one=1,two=2', [('one', '1'), ('two', '2')]),
     ('--enable-features=feat', []),
 ])
-def test_pass_through_existing_settings(config_stub, monkeypatch, flag, expected):
+def test_pass_through_existing_settings(config_stub, flag, expected):
     config_stub.val.colors.webpage.darkmode.enabled = True
     versions = version.WebEngineVersions.from_pyqt('5.15.1')
-    monkeypatch.setattr(version, 'qtwebengine_versions', lambda avoid_init: versions)
-    settings = darkmode.settings([flag])
+    settings = darkmode.settings(versions=versions, special_flags=[flag])
 
     dark_mode_expected = [
         ('darkModeEnabled', 'true'),
diff --git a/tests/unit/config/test_qtargs.py b/tests/unit/config/test_qtargs.py
index d26b5a778..82e4c2b16 100644
--- a/tests/unit/config/test_qtargs.py
+++ b/tests/unit/config/test_qtargs.py
@@ -40,11 +40,20 @@ def parser(mocker):
 
 
 @pytest.fixture
-def reduce_args(monkeypatch, config_stub):
+def version_patcher(monkeypatch):
+    """Get a patching function to patch the QtWebEngine version."""
+    def run(ver):
+        versions = version.WebEngineVersions.from_pyqt(ver)
+        monkeypatch.setattr(qtargs.objects, 'backend', usertypes.Backend.QtWebEngine)
+        monkeypatch.setattr(version, 'qtwebengine_versions', lambda avoid_init: versions)
+
+    return run
+
+
+@pytest.fixture
+def reduce_args(config_stub, version_patcher):
     """Make sure no --disable-shared-workers/referer argument get added."""
-    monkeypatch.setattr(qtargs.qtutils, 'qVersion', lambda: '5.15.0')
-    versions = version.WebEngineVersions.from_pyqt('5.15.0')
-    monkeypatch.setattr(version, 'qtwebengine_versions', lambda avoid_init: versions)
+    version_patcher('5.15.0')
     config_stub.val.content.headers.referer = 'always'
 
 
@@ -107,31 +116,30 @@ class TestWebEngineArgs:
         (usertypes.Backend.QtWebEngine, True),
         (usertypes.Backend.QtWebKit, False),
     ])
-    def test_shared_workers(self, config_stub, monkeypatch, parser,
+    def test_shared_workers(self, config_stub, version_patcher, monkeypatch, parser,
                             backend, expected):
-        monkeypatch.setattr(qtargs.qtutils, 'qVersion', lambda: '5.14.0')
+        version_patcher('5.14.0')
         monkeypatch.setattr(qtargs.objects, 'backend', backend)
         parsed = parser.parse_args([])
         args = qtargs.qt_args(parsed)
         assert ('--disable-shared-workers' in args) == expected
 
-    @pytest.mark.parametrize('backend, version_check, debug_flag, expected', [
+    @pytest.mark.parametrize('backend, qt_version, debug_flag, expected', [
         # Qt >= 5.12.3: Enable with -D stack, do nothing without it.
-        (usertypes.Backend.QtWebEngine, True, True, True),
-        (usertypes.Backend.QtWebEngine, True, False, None),
+        (usertypes.Backend.QtWebEngine, '5.12.3', True, True),
+        (usertypes.Backend.QtWebEngine, '5.12.3', False, None),
         # Qt < 5.12.3: Do nothing with -D stack, disable without it.
-        (usertypes.Backend.QtWebEngine, False, True, None),
-        (usertypes.Backend.QtWebEngine, False, False, False),
+        (usertypes.Backend.QtWebEngine, '5.12.2', True, None),
+        (usertypes.Backend.QtWebEngine, '5.12.2', False, False),
         # QtWebKit: Do nothing
-        (usertypes.Backend.QtWebKit, True, True, None),
-        (usertypes.Backend.QtWebKit, True, False, None),
-        (usertypes.Backend.QtWebKit, False, True, None),
-        (usertypes.Backend.QtWebKit, False, False, None),
+        (usertypes.Backend.QtWebKit, '5.12.3', True, None),
+        (usertypes.Backend.QtWebKit, '5.12.3', False, None),
+        (usertypes.Backend.QtWebKit, '5.12.2', True, None),
+        (usertypes.Backend.QtWebKit, '5.12.2', False, None),
     ])
-    def test_in_process_stack_traces(self, monkeypatch, parser, backend,
-                                     version_check, debug_flag, expected):
-        monkeypatch.setattr(qtargs.qtutils, 'version_check',
-                            lambda version, compiled=False, exact=False: version_check)
+    def test_in_process_stack_traces(self, monkeypatch, parser, backend, version_patcher,
+                                     qt_version, debug_flag, expected):
+        version_patcher(qt_version)
         monkeypatch.setattr(qtargs.objects, 'backend', backend)
         parsed = parser.parse_args(['--debug-flag', 'stack'] if debug_flag
                                    else [])
@@ -153,8 +161,7 @@ class TestWebEngineArgs:
         (['--debug-flag', 'wait-renderer-process'], ['--renderer-startup-dialog']),
     ])
     def test_chromium_flags(self, monkeypatch, parser, flags, args):
-        monkeypatch.setattr(qtargs.objects, 'backend',
-                            usertypes.Backend.QtWebEngine)
+        monkeypatch.setattr(qtargs.objects, 'backend', usertypes.Backend.QtWebEngine)
         parsed = parser.parse_args(flags)
         args = qtargs.qt_args(parsed)
 
@@ -172,10 +179,8 @@ class TestWebEngineArgs:
         ('software-opengl', False),
         ('chromium', True),
     ])
-    def test_disable_gpu(self, config, added,
-                         config_stub, monkeypatch, parser):
-        monkeypatch.setattr(qtargs.objects, 'backend',
-                            usertypes.Backend.QtWebEngine)
+    def test_disable_gpu(self, config, added, config_stub, monkeypatch, parser):
+        monkeypatch.setattr(qtargs.objects, 'backend', usertypes.Backend.QtWebEngine)
         config_stub.val.qt.force_software_rendering = config
         parsed = parser.parse_args([])
         args = qtargs.qt_args(parsed)
@@ -196,10 +201,8 @@ class TestWebEngineArgs:
          '--force-webrtc-ip-handling-policy='
          'disable_non_proxied_udp'),
     ])
-    def test_webrtc(self, config_stub, monkeypatch, parser,
-                    policy, arg):
-        monkeypatch.setattr(qtargs.objects, 'backend',
-                            usertypes.Backend.QtWebEngine)
+    def test_webrtc(self, config_stub, monkeypatch, parser, policy, arg):
+        monkeypatch.setattr(qtargs.objects, 'backend', usertypes.Backend.QtWebEngine)
         config_stub.val.content.webrtc_ip_handling_policy = policy
 
         parsed = parser.parse_args([])
@@ -217,8 +220,7 @@ class TestWebEngineArgs:
     ])
     def test_canvas_reading(self, config_stub, monkeypatch, parser,
                             canvas_reading, added):
-        monkeypatch.setattr(qtargs.objects, 'backend',
-                            usertypes.Backend.QtWebEngine)
+        monkeypatch.setattr(qtargs.objects, 'backend', usertypes.Backend.QtWebEngine)
 
         config_stub.val.content.canvas_reading = canvas_reading
         parsed = parser.parse_args([])
@@ -232,8 +234,7 @@ class TestWebEngineArgs:
     ])
     def test_process_model(self, config_stub, monkeypatch, parser,
                            process_model, added):
-        monkeypatch.setattr(qtargs.objects, 'backend',
-                            usertypes.Backend.QtWebEngine)
+        monkeypatch.setattr(qtargs.objects, 'backend', usertypes.Backend.QtWebEngine)
 
         config_stub.val.qt.process_model = process_model
         parsed = parser.parse_args([])
@@ -254,8 +255,7 @@ class TestWebEngineArgs:
     ])
     def test_low_end_device_mode(self, config_stub, monkeypatch, parser,
                                  low_end_device_mode, arg):
-        monkeypatch.setattr(qtargs.objects, 'backend',
-                            usertypes.Backend.QtWebEngine)
+        monkeypatch.setattr(qtargs.objects, 'backend', usertypes.Backend.QtWebEngine)
 
         config_stub.val.qt.low_end_device_mode = low_end_device_mode
         parsed = parser.parse_args([])
@@ -284,9 +284,10 @@ class TestWebEngineArgs:
         ('5.14.0', 'same-domain', '--enable-features=ReducedReferrerGranularity'),
         ('5.15.0', 'same-domain', '--enable-features=ReducedReferrerGranularity'),
     ])
-    def test_referer(self, config_stub, monkeypatch, parser, qt_version, referer, arg):
+    def test_referer(self, config_stub, monkeypatch, version_patcher, parser,
+                     qt_version, referer, arg):
         monkeypatch.setattr(qtargs.objects, 'backend', usertypes.Backend.QtWebEngine)
-        monkeypatch.setattr(qtargs.qtutils, 'qVersion', lambda: qt_version)
+        version_patcher(qt_version)
 
         # Avoid WebRTC pipewire feature
         monkeypatch.setattr(qtargs.utils, 'is_linux', False)
@@ -334,10 +335,8 @@ class TestWebEngineArgs:
     ])
     @utils.qt514
     def test_preferred_color_scheme(
-            self, config_stub, monkeypatch, parser, value, qt_version, added):
-        monkeypatch.setattr(qtargs.objects, 'backend',
-                            usertypes.Backend.QtWebEngine)
-        monkeypatch.setattr(qtargs.qtutils, 'qVersion', lambda: qt_version)
+            self, config_stub, version_patcher, parser, value, qt_version, added):
+        version_patcher(qt_version)
 
         config_stub.val.colors.webpage.preferred_color_scheme = value
 
@@ -358,8 +357,7 @@ class TestWebEngineArgs:
     ])
     def test_overlay_scrollbar(self, config_stub, monkeypatch, parser,
                                bar, is_mac, added):
-        monkeypatch.setattr(qtargs.objects, 'backend',
-                            usertypes.Backend.QtWebEngine)
+        monkeypatch.setattr(qtargs.objects, 'backend', usertypes.Backend.QtWebEngine)
         monkeypatch.setattr(qtargs.utils, 'is_mac', is_mac)
         # Avoid WebRTC pipewire feature
         monkeypatch.setattr(qtargs.utils, 'is_linux', False)
@@ -372,14 +370,10 @@ class TestWebEngineArgs:
         assert ('--enable-features=OverlayScrollbar' in args) == added
 
     @pytest.fixture
-    def feature_flag_patch(self, monkeypatch, config_stub):
+    def feature_flag_patch(self, monkeypatch, config_stub, version_patcher):
         """Patch away things affecting feature flags."""
         config_stub.val.scrolling.bar = 'never'
-        monkeypatch.setattr(qtargs.objects, 'backend',
-                            usertypes.Backend.QtWebEngine)
-        monkeypatch.setattr(qtargs.qtutils, 'version_check',
-                            lambda version, exact=False, compiled=True:
-                            True)
+        version_patcher('5.15.3')
         monkeypatch.setattr(qtargs.utils, 'is_mac', False)
         # Avoid WebRTC pipewire feature
         monkeypatch.setattr(qtargs.utils, 'is_linux', False)
@@ -465,10 +459,8 @@ class TestWebEngineArgs:
         ('5.15.3', False),
         ('6.0.0', False),
     ])
-    def test_installedapp_workaround(self, parser, monkeypatch, qt_version, has_workaround):
-        monkeypatch.setattr(qtargs.qtutils, 'qVersion', lambda: qt_version)
-        monkeypatch.setattr(qtargs.objects, 'backend',
-                            usertypes.Backend.QtWebEngine)
+    def test_installedapp_workaround(self, parser, version_patcher, qt_version, has_workaround):
+        version_patcher(qt_version)
 
         parsed = parser.parse_args([])
         args = qtargs.qt_args(parsed)
@@ -507,7 +499,8 @@ class TestWebEngineArgs:
                                 variant, expected):
         from qutebrowser.browser.webengine import darkmode
         monkeypatch.setattr(qtargs.objects, 'backend', usertypes.Backend.QtWebEngine)
-        monkeypatch.setattr(darkmode, '_variant', lambda: darkmode.Variant[variant])
+        monkeypatch.setattr(
+            darkmode, '_variant', lambda _versions: darkmode.Variant[variant])
 
         config_stub.val.colors.webpage.darkmode.enabled = True