diff --git a/stl/inc/optional b/stl/inc/optional
index 6b885027223..a86eaa23be7 100644
--- a/stl/inc/optional
+++ b/stl/inc/optional
@@ -926,7 +926,7 @@ _NODISCARD constexpr bool operator>=(const _Ty1& _Left, const optional<_Ty2>& _R
 #ifdef __cpp_lib_concepts
 // clang-format off
 _EXPORT_STD template <class _Ty1, class _Ty2>
-    requires (!_Is_specialization_v<_Ty2, optional>)
+    requires (!_Derived_from_specialization_of<_Ty2, optional>)
         && three_way_comparable_with<_Ty1, _Ty2>
 _NODISCARD constexpr compare_three_way_result_t<_Ty1, _Ty2>
     operator<=>(const optional<_Ty1>& _Left, const _Ty2& _Right)
diff --git a/stl/inc/xutility b/stl/inc/xutility
index df7fb2358b4..c0b12de5790 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -404,6 +404,15 @@ using _Algorithm_int_t = conditional_t<is_integral_v<_Ty>, _Ty, ptrdiff_t>;
 template <class _Ty>
 concept _Destructible_object = is_object_v<_Ty> && destructible<_Ty>;
 
+template <template <class...> class _Template, class... _Args>
+void _Derived_from_specialization_impl(const _Template<_Args...>&);
+
+template <class _Ty, template <class...> class _Template>
+concept _Derived_from_specialization_of =
+    requires(const _Ty& _Obj) {
+        _STD _Derived_from_specialization_impl<_Template>(_Obj); // qualified: avoid ADL, handle incomplete types
+    };
+
 namespace ranges {
     namespace _Iter_move {
 #if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
@@ -2932,15 +2941,9 @@ namespace ranges {
 
     _EXPORT_STD struct view_base {};
 
-    template <template <class...> class _Template, class... _Args>
-    void _Derived_from_specialization_impl(const _Template<_Args...>&);
-
     template <class _Ty, template <class...> class _Template>
-    concept _Derived_from_specialization_of =
-        is_object_v<_Ty> && requires(const _Ty& _Obj) {
-                                _RANGES _Derived_from_specialization_impl<_Template>(
-                                    _Obj); // qualified: avoid ADL, handle incompletable types
-                            };
+    concept _Strictly_derived_from_specialization_of =
+        is_object_v<_Ty> && _Derived_from_specialization_of<_Ty, _Template>;
 
     _EXPORT_STD template <class _Derived>
         requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
@@ -2948,7 +2951,7 @@ namespace ranges {
 
     _EXPORT_STD template <class _Ty>
     inline constexpr bool enable_view =
-        derived_from<_Ty, view_base> || _Derived_from_specialization_of<_Ty, view_interface>;
+        derived_from<_Ty, view_base> || _Strictly_derived_from_specialization_of<_Ty, view_interface>;
 
     _EXPORT_STD template <class _Ty>
     concept view = range<_Ty> && movable<_Ty> && enable_view<_Ty>;
diff --git a/tests/std/tests/P1614R2_spaceship/test.cpp b/tests/std/tests/P1614R2_spaceship/test.cpp
index daeccca953c..46303176e35 100644
--- a/tests/std/tests/P1614R2_spaceship/test.cpp
+++ b/tests/std/tests/P1614R2_spaceship/test.cpp
@@ -290,6 +290,11 @@ constexpr bool tuple_like_test() {
     return true;
 }
 
+template <class T>
+struct derived_optional : std::optional<T> {
+    friend bool operator==(const derived_optional&, const derived_optional&) = default;
+};
+
 template <auto SmallVal, decltype(SmallVal) EqualVal, decltype(EqualVal) LargeVal>
 constexpr bool optional_test() {
     using ReturnType = std::compare_three_way_result_t<decltype(SmallVal)>;
@@ -310,8 +315,13 @@ constexpr bool optional_test() {
     }
     {
         constexpr std::optional o1(SmallVal);
+        constexpr derived_optional<decltype(SmallVal)> derived1{std::optional(SmallVal)};
+        constexpr derived_optional<decltype(SmallVal)> derived2{std::optional(LargeVal)};
+
+        static_assert(!std::three_way_comparable<derived_optional<decltype(SmallVal)>>);
 
         assert(spaceship_test<ReturnType>(o1, EqualVal, LargeVal));
+        assert(spaceship_test<ReturnType>(o1, derived1, derived2));
     }
     {
         constexpr std::optional<decltype(SmallVal)> o1(std::nullopt);