diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c0ce631..fac296d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -10,6 +10,7 @@ on:
 
 env:
   UBSAN_OPTIONS: print_stacktrace=1
+  ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION: true
 
 jobs:
   posix:
diff --git a/doc/variant2/reference.adoc b/doc/variant2/reference.adoc
index 59b9cb2..0ce2453 100644
--- a/doc/variant2/reference.adoc
+++ b/doc/variant2/reference.adoc
@@ -845,6 +845,9 @@ template<class... T>
 [none]
 * {blank}
 +
+Constraints: :: `std::declval<const Ti&>() == std::declval<const Ti&>()` is a valid expression 
+  convertible to `bool` for all `Ti` in `T...`.
++
 Returns: :: `v.index() == w.index() && get<I>(v) == get<I>(w)`, where `I`
   is `v.index()`.
 
@@ -855,6 +858,9 @@ template<class... T>
 [none]
 * {blank}
 +
+Constraints: :: `std::declval<const Ti&>() != std::declval<const Ti&>()` is a valid expression 
+  convertible to `bool` for all `Ti` in `T...`.
++
 Returns: :: `!(v == w)`.
 
 ```
@@ -864,6 +870,9 @@ template<class... T>
 [none]
 * {blank}
 +
+Constraints: :: `std::declval<const Ti&>() < std::declval<const Ti&>()` is a valid expression 
+  convertible to `bool` for all `Ti` in `T...`.
++
 Returns: :: `v.index() < w.index() || (v.index() == w.index() && get<I>(v) < get<I>(w))`,
   where `I` is `v.index()`.
 
@@ -874,6 +883,9 @@ template<class... T>
 [none]
 * {blank}
 +
+Constraints: :: `std::declval<const Ti&>() < std::declval<const Ti&>()` is a valid expression 
+  convertible to `bool` for all `Ti` in `T...`.
++
 Returns: :: `w < v`.
 
 ```
@@ -883,6 +895,9 @@ template<class... T>
 [none]
 * {blank}
 +
+Constraints: :: `std::declval<const Ti&>() \<= std::declval<const Ti&>()` is a valid expression 
+  convertible to `bool` for all `Ti` in `T...`.
++
 Returns: :: `v.index() < w.index() || (v.index() == w.index() && get<I>(v) \<= get<I>(w))`,
   where `I` is `v.index()`.
 
@@ -893,6 +908,9 @@ template<class... T>
 [none]
 * {blank}
 +
+Constraints: :: `std::declval<const Ti&>() \<= std::declval<const Ti&>()` is a valid expression 
+  convertible to `bool` for all `Ti` in `T...`.
++
 Returns: ::
   `w \<= v`.
 
diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
index bb94c27..cff1c3e 100644
--- a/include/boost/variant2/variant.hpp
+++ b/include/boost/variant2/variant.hpp
@@ -2103,6 +2103,45 @@ template<class... T> class variant: private detail::variant_ma_base<T...>
 namespace detail
 {
 
+namespace relops_constraints
+{
+
+#if !defined(BOOST_NO_SFINAE_EXPR) && \
+    !BOOST_WORKAROUND(BOOST_MSVC, < 1900) && !BOOST_WORKAROUND(BOOST_GCC, < 40900)
+
+template<class...> struct make_void { typedef void type; };
+
+#define BOOST_VARIANT2_DEFINE_RELOP_CONSTRAINT( name, op ) \
+template<class T, class = void> struct name: std::false_type {}; \
+\
+template<class T> struct name<T, typename make_void< \
+    decltype( std::declval<const T&>() op std::declval<const T&>() )>::type>: \
+    std::is_convertible<decltype( std::declval<const T&>() op std::declval<const T&>() ), bool> \
+{ \
+};
+
+#else
+
+// non-expression-SFINAE fallback does not work with deleted relops: 
+// variant's relop instantiation fails instead, which is good enough
+
+struct not_comparable {};
+template<class U> not_comparable operator==( U const &, U const & );
+template<class U> not_comparable operator!=( U const &, U const & );
+template<class U> not_comparable operator< ( U const &, U const & );
+template<class U> not_comparable operator<=( U const &, U const & );
+
+#define BOOST_VARIANT2_DEFINE_RELOP_CONSTRAINT( name, op ) \
+template<class T> struct name: std::is_convertible<decltype( std::declval<const T&>() op std::declval<const T&>() ), bool> \
+{ \
+};
+
+#endif
+
+BOOST_VARIANT2_DEFINE_RELOP_CONSTRAINT( has_eq, == )
+
+} // namespace relops_constraints
+
 template<class... T> struct eq_L
 {
     variant<T...> const & v;
@@ -2116,7 +2155,8 @@ template<class... T> struct eq_L
 
 } // namespace detail
 
-template<class... T> constexpr bool operator==( variant<T...> const & v, variant<T...> const & w )
+template<class... T,  class E = typename std::enable_if<mp11::mp_all<detail::relops_constraints::has_eq<T>...>::value>::type>
+constexpr bool operator==( variant<T...> const & v, variant<T...> const & w )
 {
     return v.index() == w.index() && mp11::mp_with_index<sizeof...(T)>( v.index(), detail::eq_L<T...>{ v, w } );
 }
@@ -2124,6 +2164,13 @@ template<class... T> constexpr bool operator==( variant<T...> const & v, variant
 namespace detail
 {
 
+namespace relops_constraints
+{
+
+BOOST_VARIANT2_DEFINE_RELOP_CONSTRAINT( has_ne, != )
+
+} // namespace relops_constraints
+
 template<class... T> struct ne_L
 {
     variant<T...> const & v;
@@ -2137,7 +2184,8 @@ template<class... T> struct ne_L
 
 } // namespace detail
 
-template<class... T> constexpr bool operator!=( variant<T...> const & v, variant<T...> const & w )
+template<class... T,  class E = typename std::enable_if<mp11::mp_all<detail::relops_constraints::has_ne<T>...>::value>::type>
+constexpr bool operator!=( variant<T...> const & v, variant<T...> const & w )
 {
     return v.index() != w.index() || mp11::mp_with_index<sizeof...(T)>( v.index(), detail::ne_L<T...>{ v, w } );
 }
@@ -2145,6 +2193,13 @@ template<class... T> constexpr bool operator!=( variant<T...> const & v, variant
 namespace detail
 {
 
+namespace relops_constraints
+{
+
+BOOST_VARIANT2_DEFINE_RELOP_CONSTRAINT( has_lt, < )
+
+} // namespace relops_constraints
+
 template<class... T> struct lt_L
 {
     variant<T...> const & v;
@@ -2158,12 +2213,14 @@ template<class... T> struct lt_L
 
 } // namespace detail
 
-template<class... T> constexpr bool operator<( variant<T...> const & v, variant<T...> const & w )
+template<class... T,  class E = typename std::enable_if<mp11::mp_all<detail::relops_constraints::has_lt<T>...>::value>::type>
+constexpr bool operator<( variant<T...> const & v, variant<T...> const & w )
 {
     return v.index() < w.index() || ( v.index() == w.index() && mp11::mp_with_index<sizeof...(T)>( v.index(), detail::lt_L<T...>{ v, w } ) );
 }
 
-template<class... T> constexpr bool operator>(  variant<T...> const & v, variant<T...> const & w )
+template<class... T,  class E = typename std::enable_if<mp11::mp_all<detail::relops_constraints::has_lt<T>...>::value>::type>
+constexpr bool operator>(  variant<T...> const & v, variant<T...> const & w )
 {
     return w < v;
 }
@@ -2171,6 +2228,14 @@ template<class... T> constexpr bool operator>(  variant<T...> const & v, variant
 namespace detail
 {
 
+namespace relops_constraints
+{
+
+BOOST_VARIANT2_DEFINE_RELOP_CONSTRAINT( has_le, <= )
+#undef BOOST_VARIANT2_DEFINE_RELOP_CONSTRAINT
+
+} // namespace relops_constraints
+
 template<class... T> struct le_L
 {
     variant<T...> const & v;
@@ -2184,12 +2249,14 @@ template<class... T> struct le_L
 
 } // namespace detail
 
-template<class... T> constexpr bool operator<=( variant<T...> const & v, variant<T...> const & w )
+template<class... T,  class E = typename std::enable_if<mp11::mp_all<detail::relops_constraints::has_le<T>...>::value>::type>
+constexpr bool operator<=( variant<T...> const & v, variant<T...> const & w )
 {
     return v.index() < w.index() || ( v.index() == w.index() && mp11::mp_with_index<sizeof...(T)>( v.index(), detail::le_L<T...>{ v, w } ) );
 }
 
-template<class... T> constexpr bool operator>=( variant<T...> const & v, variant<T...> const & w )
+template<class... T,  class E = typename std::enable_if<mp11::mp_all<detail::relops_constraints::has_le<T>...>::value>::type>
+constexpr bool operator>=( variant<T...> const & v, variant<T...> const & w )
 {
     return w <= v;
 }
diff --git a/test/Jamfile b/test/Jamfile
index 4d88ebf..d8c3a77 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -180,3 +180,5 @@ run variant_issue_55.cpp
     # clang-cl 32 bit fails with an assertion in mp_with_index, likely due to a codegen bug
     "<toolset>clang-win,<address-model>32:<build>no"
   ;
+
+run variant_constrained_relops.cpp ;
diff --git a/test/variant_constrained_relops.cpp b/test/variant_constrained_relops.cpp
new file mode 100644
index 0000000..ed3ad40
--- /dev/null
+++ b/test/variant_constrained_relops.cpp
@@ -0,0 +1,213 @@
+
+// Copyright 2026 Joaquin M Lopez Munoz.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <functional>
+#include <type_traits>
+
+#if !defined(BOOST_NO_SFINAE_EXPR) && \
+    !BOOST_WORKAROUND(BOOST_MSVC, < 1900) && !BOOST_WORKAROUND(BOOST_GCC, < 40900)
+#define USE_DELETED_RELOPS
+#endif
+
+using namespace boost::variant2;
+
+struct not_found {};
+struct variant_sink { template<class... T> variant_sink( variant<T...> const & ); };
+not_found operator==( variant_sink const &, variant_sink const & );
+not_found operator!=( variant_sink const &, variant_sink const & );
+not_found operator< ( variant_sink const &, variant_sink const & );
+not_found operator<=( variant_sink const &, variant_sink const & );
+not_found operator> ( variant_sink const &, variant_sink const & );
+not_found operator>=( variant_sink const &, variant_sink const & );
+
+struct no_eq
+{
+#ifdef USE_DELETED_RELOPS
+    bool operator==( const no_eq& ) const = delete;
+#endif
+    int  operator!=( const no_eq& ) const;
+    int  operator< ( const no_eq& ) const;
+    int  operator<=( const no_eq& ) const;
+};
+
+struct bad_eq
+{
+    void operator==( const bad_eq& ) const;
+    int  operator!=( const bad_eq& ) const;
+    int  operator< ( const bad_eq& ) const;
+    int  operator<=( const bad_eq& ) const;
+};
+
+struct no_ne
+{
+    int  operator==( const no_ne& ) const;
+#ifdef USE_DELETED_RELOPS
+    bool operator!=( const no_ne& ) const = delete;
+#endif
+    int  operator< ( const no_ne& ) const;
+    int  operator<=( const no_ne& ) const;
+};
+
+struct bad_ne
+{
+    int  operator==( const bad_ne& ) const;
+    void operator!=( const bad_ne& ) const;
+    int  operator< ( const bad_ne& ) const;
+    int  operator<=( const bad_ne& ) const;
+};
+
+struct no_lt
+{
+    int  operator==( const no_lt& ) const;
+    int  operator!=( const no_lt& ) const;
+#ifdef USE_DELETED_RELOPS
+    bool operator< ( const no_lt& ) const = delete;
+#endif
+    int  operator<=( const no_lt& ) const;
+};
+
+struct bad_lt
+{
+    int  operator==( const bad_lt& ) const;
+    int  operator!=( const bad_lt& ) const;
+    void operator< ( const bad_lt& ) const;
+    int  operator<=( const bad_lt& ) const;
+};
+
+struct no_le
+{
+    int  operator==( const no_le& ) const;
+    int  operator!=( const no_le& ) const;
+    int  operator< ( const no_le& ) const;
+#ifdef USE_DELETED_RELOPS
+    bool operator<=( const no_le& ) const = delete;
+#endif
+};
+
+struct bad_le
+{
+    int  operator==( const bad_le& ) const;
+    int  operator!=( const bad_le& ) const;
+    int  operator< ( const bad_le& ) const;
+    void operator<=( const bad_le& ) const;
+};
+
+struct non_comparable {};
+
+template<typename T>
+struct wrapper
+{ 
+    T t; 
+    bool operator<(const wrapper& x) const { return t < x.t; }; 
+};
+
+int main()
+{
+    {
+        using v_t = const variant<int, no_eq>&;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() == std::declval<v_t>() ), not_found>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() != std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <  std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <= std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >  std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >= std::declval<v_t>() ), bool     >));
+    }
+
+    {
+        using v_t = const variant<int, bad_eq>&;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() == std::declval<v_t>() ), not_found>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() != std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <  std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <= std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >  std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >= std::declval<v_t>() ), bool     >));
+    }
+
+    {
+        using v_t = const variant<int, no_ne>&;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() == std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( operator!=( std::declval<v_t>(), std::declval<v_t>() ) ), not_found>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <  std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <= std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >  std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >= std::declval<v_t>() ), bool     >));
+    }
+
+    {
+        using v_t = const variant<int, bad_ne>&;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() == std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( operator!=( std::declval<v_t>(), std::declval<v_t>() ) ), not_found>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <  std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <= std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >  std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >= std::declval<v_t>() ), bool     >));
+    }
+
+    {
+        using v_t = const variant<int, no_lt>&;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() == std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() != std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <  std::declval<v_t>() ), not_found>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <= std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >  std::declval<v_t>() ), not_found>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >= std::declval<v_t>() ), bool     >));
+    }
+
+    {
+        using v_t = const variant<int, bad_lt>&;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() == std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() != std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <  std::declval<v_t>() ), not_found>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <= std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >  std::declval<v_t>() ), not_found>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >= std::declval<v_t>() ), bool     >));
+    }
+
+    {
+        using v_t = const variant<int, no_le>&;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() == std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() != std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <  std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <= std::declval<v_t>() ), not_found>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >  std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >= std::declval<v_t>() ), not_found>));
+    }
+
+    {
+        using v_t = const variant<int, bad_le>&;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() == std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() != std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <  std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() <= std::declval<v_t>() ), not_found>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >  std::declval<v_t>() ), bool     >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype( std::declval<v_t>() >= std::declval<v_t>() ), not_found>));
+    }
+
+    {
+        //https://github.com/boostorg/variant2/issues/60
+
+        using v_t = variant<non_comparable>;
+        using reference_wrapper = std::reference_wrapper<v_t>;
+
+        wrapper<reference_wrapper*> x{nullptr}, y{nullptr};
+        (void)(x < y);
+    }
+
+    return boost::report_errors();
+}