diff --git a/stl/inc/chrono b/stl/inc/chrono
index deed0e8b51f..dcb809a8341 100644
--- a/stl/inc/chrono
+++ b/stl/inc/chrono
@@ -2460,86 +2460,88 @@ namespace chrono {
     public:
         using duration = common_type_t<_Duration, seconds>;
 
-        template <class _Traits2 = _Traits, class = void_t<decltype(_Traits2::default_zone())>>
-        zoned_time() : _Zone{_Traits::default_zone()} {}
+        zoned_time()
+            requires requires { _Traits::default_zone(); }
+            : _Zone{_Traits::default_zone()} {}
+
         zoned_time(const zoned_time&)            = default;
         zoned_time& operator=(const zoned_time&) = default;
 
-        template <class _Traits2 = _Traits, class = void_t<decltype(_Traits2::default_zone())>>
-        zoned_time(const sys_time<_Duration>& _Sys) : _Zone{_Traits::default_zone()}, _Tp{_Sys} {}
+        zoned_time(const sys_time<_Duration>& _Sys)
+            requires requires { _Traits::default_zone(); }
+            : _Zone{_Traits::default_zone()}, _Tp{_Sys} {}
 
         explicit zoned_time(_TimeZonePtr _Tz) noexcept /* strengthened */ : _Zone{_STD move(_Tz)} {}
 
-        template <class _Traits2                                                                             = _Traits,
-            enable_if_t<is_constructible_v<zoned_time, decltype(_Traits2::locate_zone(string_view{}))>, int> = 0>
-        explicit zoned_time(string_view _Name) : _Zone{_Traits::locate_zone(_Name)} {}
+        explicit zoned_time(string_view _Name)
+            requires requires {
+                { _Traits::locate_zone(_Name) } -> convertible_to<_TimeZonePtr>;
+            }
+            : _Zone{_Traits::locate_zone(_Name)} {}
 
-        template <class _Duration2, enable_if_t<is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>, int> = 0>
+        template <class _Duration2>
+            requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
         zoned_time(const zoned_time<_Duration2, _TimeZonePtr>& _Zt) noexcept /* strengthened */
             : _Zone{_Zt.get_time_zone()}, _Tp{_Zt.get_sys_time()} {}
 
         zoned_time(_TimeZonePtr _Tz, const sys_time<_Duration>& _Sys) : _Zone{_STD move(_Tz)}, _Tp{_Sys} {}
 
-        template <class _Traits2 = _Traits,
-            enable_if_t<is_constructible_v<zoned_time, decltype(_Traits2::locate_zone(string_view{})),
-                            const sys_time<_Duration>&>,
-                int>             = 0>
         zoned_time(string_view _Name, type_identity_t<const sys_time<_Duration>&> _Sys)
-            : zoned_time{_Traits::locate_zone(_Name), _Sys} {}
+            requires requires {
+                { _Traits::locate_zone(_Name) } -> convertible_to<_TimeZonePtr>;
+            }
+            : _Zone{_Traits::locate_zone(_Name)}, _Tp{_Sys} {}
 
-        template <class _Ptr = _TimeZonePtr,
-            enable_if_t<
-                is_convertible_v<decltype(_STD declval<_Ptr&>()->to_sys(local_time<_Duration>{})), sys_time<duration>>,
-                int> = 0>
         zoned_time(_TimeZonePtr _Tz, const local_time<_Duration>& _Local)
+            requires requires {
+                { _Tz->to_sys(_Local) } -> convertible_to<sys_time<duration>>;
+            }
             : _Zone{_STD move(_Tz)}, _Tp{_Zone->to_sys(_Local)} {}
 
-        template <class _Traits2 = _Traits,
-            enable_if_t<is_constructible_v<zoned_time, decltype(_Traits2::locate_zone(string_view{})),
-                            const local_time<_Duration>&>,
-                int>             = 0>
-        zoned_time(string_view _Name, type_identity_t<const local_time<_Duration>>& _Local)
-            : zoned_time{_Traits::locate_zone(_Name), _Local} {}
-
-        template <class _Ptr = _TimeZonePtr,
-            enable_if_t<
-                is_convertible_v<decltype(_STD declval<_Ptr&>()->to_sys(local_time<_Duration>{}, choose::earliest)),
-                    sys_time<duration>>,
-                int> = 0>
+        zoned_time(string_view _Name, type_identity_t<const local_time<_Duration>&> _Local)
+            requires requires {
+                { _Traits::locate_zone(_Name) } -> convertible_to<_TimeZonePtr>;
+                { _STD declval<_TimeZonePtr&>() -> to_sys(_Local) } -> convertible_to<sys_time<duration>>;
+            }
+            : _Zone{_Traits::locate_zone(_Name)}, _Tp{_Zone->to_sys(_Local)} {}
+
         zoned_time(_TimeZonePtr _Tz, const local_time<_Duration>& _Local, choose _Choose)
+            requires requires {
+                { _Tz->to_sys(_Local, _Choose) } -> convertible_to<sys_time<duration>>;
+            }
             : _Zone{_STD move(_Tz)}, _Tp{_Zone->to_sys(_Local, _Choose)} {}
 
-        template <class _Traits2 = _Traits,
-            enable_if_t<is_constructible_v<zoned_time, decltype(_Traits2::locate_zone(string_view{})),
-                            const local_time<_Duration>&, choose>,
-                int>             = 0>
         zoned_time(string_view _Name, type_identity_t<const local_time<_Duration>&> _Local, choose _Choose)
-            : zoned_time{_Traits::locate_zone(_Name), _Local, _Choose} {}
+            requires requires {
+                { _Traits::locate_zone(_Name) } -> convertible_to<_TimeZonePtr>;
+                { _STD declval<_TimeZonePtr&>() -> to_sys(_Local, _Choose) } -> convertible_to<sys_time<duration>>;
+            }
+            : _Zone{_Traits::locate_zone(_Name)}, _Tp{_Zone->to_sys(_Local, _Choose)} {}
 
-        template <class _Duration2, class _TimeZonePtr2,
-            enable_if_t<is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>, int> = 0>
+        template <class _Duration2, class _TimeZonePtr2>
+            requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
         zoned_time(_TimeZonePtr _Tz, const zoned_time<_Duration2, _TimeZonePtr2>& _Zt) noexcept /* strengthened */
             : _Zone{_STD move(_Tz)}, _Tp{_Zt.get_sys_time()} {}
 
-        template <class _Duration2, class _TimeZonePtr2,
-            enable_if_t<is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>, int> = 0>
+        template <class _Duration2, class _TimeZonePtr2>
+            requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
         zoned_time(
             _TimeZonePtr _Tz, const zoned_time<_Duration2, _TimeZonePtr2>& _Zt, choose) noexcept /* strengthened */
-            : zoned_time{_Tz, _Zt} {}
+            : _Zone{_STD move(_Tz)}, _Tp{_Zt.get_sys_time()} {}
 
-        template <class _Duration2, class _TimeZonePtr2, class _Traits2 = _Traits,
-            enable_if_t<is_constructible_v<zoned_time, decltype(_Traits2::locate_zone(string_view{})),
-                            const zoned_time<_Duration2, _TimeZonePtr2>&>,
-                int> = 0>
+        template <class _Duration2, class _TimeZonePtr2>
         zoned_time(string_view _Name, const zoned_time<_Duration2, _TimeZonePtr2>& _Zt)
-            : zoned_time{_Traits::locate_zone(_Name), _Zt} {}
-
-        template <class _Duration2, class _TimeZonePtr2, class _Traits2 = _Traits,
-            enable_if_t<is_constructible_v<zoned_time, decltype(_Traits2::locate_zone(string_view{})),
-                            const zoned_time<_Duration2, _TimeZonePtr2>&, choose>,
-                int> = 0>
-        zoned_time(string_view _Name, const zoned_time<_Duration2, _TimeZonePtr2>& _Zt, choose _Choose)
-            : zoned_time{_Traits::locate_zone(_Name), _Zt, _Choose} {}
+            requires requires {
+                { _Traits::locate_zone(_Name) } -> convertible_to<_TimeZonePtr>;
+            } && is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+            : _Zone{_Traits::locate_zone(_Name)}, _Tp{_Zt.get_sys_time()} {}
+
+        template <class _Duration2, class _TimeZonePtr2>
+        zoned_time(string_view _Name, const zoned_time<_Duration2, _TimeZonePtr2>& _Zt, choose)
+            requires requires {
+                { _Traits::locate_zone(_Name) } -> convertible_to<_TimeZonePtr>;
+            } && is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+            : _Zone{_Traits::locate_zone(_Name)}, _Tp{_Zt.get_sys_time()} {}
 
         zoned_time& operator=(const sys_time<_Duration>& _Sys) noexcept /* strengthened */ {
             _Tp = _Sys;