diff --git a/include/boost/unordered/detail/allocate.hpp b/include/boost/unordered/detail/allocate.hpp
index ebc9993f..11bfa4e5 100644
--- a/include/boost/unordered/detail/allocate.hpp
+++ b/include/boost/unordered/detail/allocate.hpp
@@ -390,6 +390,7 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
     }
 
 #endif // BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT
+
 #else // BOOST_NO_VARIADIC_TEMPLATES
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -441,9 +442,9 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
 #undef BOOST_UNORDERED_CONSTRUCT_IMPL
 
     template <typename A, typename B, typename A0, typename A1, typename A2>
-    inline typename enable_if<piecewise3<A, B, A0>, void>::type
-        construct_impl(std::pair<A, B>* address,
-            boost::unordered::detail::emplace_args3<A0, A1, A2> const& args)
+    inline void construct_impl(std::pair<A, B>* address,
+            boost::unordered::detail::emplace_args3<A0, A1, A2> const& args,
+            typename enable_if<piecewise3<A, B, A0>, void*>::type = 0)
     {
         boost::unordered::detail::construct_from_tuple(
             boost::addressof(address->first), args.a1);
@@ -454,9 +455,9 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
 #if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
 
     template <typename A, typename B, typename A0>
-    inline typename enable_if<emulation1<A, B, A0>, void>::type
-        construct_impl(std::pair<A, B>* address,
-            boost::unordered::detail::emplace_args1<A0> const& args)
+    inline void construct_impl(std::pair<A, B>* address,
+            boost::unordered::detail::emplace_args1<A0> const& args,
+            typename enable_if<emulation1<A, B, A0>, void*>::type = 0)
     {
         new((void*) boost::addressof(address->first)) A(
             boost::forward<A0>(args.a0));
@@ -464,9 +465,9 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
     }
 
     template <typename A, typename B, typename A0, typename A1, typename A2>
-    inline typename enable_if<emulation3<A, B, A0>, void>::type
-        construct_impl(std::pair<A, B>* address,
-            boost::unordered::detail::emplace_args3<A0, A1, A2> const& args)
+    inline void construct_impl(std::pair<A, B>* address,
+            boost::unordered::detail::emplace_args3<A0, A1, A2> const& args,
+            typename enable_if<emulation3<A, B, A0>, void*>::type = 0)
     {
         new((void*) boost::addressof(address->first)) A(
             boost::forward<A0>(args.a0));
@@ -811,35 +812,38 @@ namespace boost { namespace unordered { namespace detail {
 #   endif
 
     template <typename Alloc>
-    inline typename boost::enable_if_c<
+    inline Alloc call_select_on_container_copy_construction(const Alloc& rhs,
+        typename boost::enable_if_c<
             boost::unordered::detail::
-            has_select_on_container_copy_construction<Alloc>::value, Alloc
-        >::type call_select_on_container_copy_construction(const Alloc& rhs)
+            has_select_on_container_copy_construction<Alloc>::value, void*
+        >::type = 0)
     {
         return rhs.select_on_container_copy_construction();
     }
 
     template <typename Alloc>
-    inline typename boost::disable_if_c<
+    inline Alloc call_select_on_container_copy_construction(const Alloc& rhs,
+        typename boost::disable_if_c<
             boost::unordered::detail::
-            has_select_on_container_copy_construction<Alloc>::value, Alloc
-        >::type call_select_on_container_copy_construction(const Alloc& rhs)
+            has_select_on_container_copy_construction<Alloc>::value, void*
+        >::type = 0)
     {
         return rhs;
     }
 
     template <typename SizeType, typename Alloc>
-    inline typename boost::enable_if_c<
-            boost::unordered::detail::has_max_size<Alloc>::value, SizeType
-        >::type call_max_size(const Alloc& a)
+    inline SizeType call_max_size(const Alloc& a,
+        typename boost::enable_if_c<
+            boost::unordered::detail::has_max_size<Alloc>::value, void*
+        >::type = 0)
     {
         return a.max_size();
     }
 
     template <typename SizeType, typename Alloc>
-    inline typename boost::disable_if_c<
-            boost::unordered::detail::has_max_size<Alloc>::value, SizeType
-        >::type call_max_size(const Alloc&)
+    inline SizeType call_max_size(const Alloc&, typename boost::disable_if_c<
+            boost::unordered::detail::has_max_size<Alloc>::value, void*
+        >::type = 0)
     {
         return (std::numeric_limits<SizeType>::max)();
     }
@@ -967,41 +971,41 @@ namespace boost { namespace unordered { namespace detail {
         // the only construct method that old fashioned allocators support.
 
         template <typename T>
-        static typename boost::enable_if_c<
-                boost::unordered::detail::has_construct<Alloc, T>::value &&
-                boost::is_same<T, value_type>::value
-            >::type
-            construct(Alloc& a, T* p, T const& x)
+        static void construct(Alloc& a, T* p, T const& x,
+            typename boost::enable_if_c<
+                    boost::unordered::detail::has_construct<Alloc, T>::value &&
+                    boost::is_same<T, value_type>::value,
+                    void*>::type = 0)
         {
             a.construct(p, x);
         }
 
         template <typename T>
-        static typename boost::disable_if_c<
+        static void construct(Alloc&, T* p, T const& x,
+            typename boost::disable_if_c<
                 boost::unordered::detail::has_construct<Alloc, T>::value &&
-                boost::is_same<T, value_type>::value
-            >::type
-            construct(Alloc&, T* p, T const& x)
+                boost::is_same<T, value_type>::value,
+                void*>::type = 0)
         {
             new ((void*) p) T(x);
         }
 
         template <typename T>
-        static typename boost::enable_if_c<
+        static void destroy(Alloc& a, T* p,
+            typename boost::enable_if_c<
                 boost::unordered::detail::has_destroy<Alloc, T>::value &&
-                boost::is_same<T, value_type>::value
-            >::type
-            destroy(Alloc& a, T* p)
+                boost::is_same<T, value_type>::value,
+                void*>::type = 0)
         {
             a.destroy(p);
         }
 
         template <typename T>
-        static typename boost::disable_if_c<
+        static void destroy(Alloc&, T* p,
+            typename boost::disable_if_c<
                 boost::unordered::detail::has_destroy<Alloc, T>::value &&
-                boost::is_same<T, value_type>::value
-            >::type
-            destroy(Alloc&, T* p)
+                boost::is_same<T, value_type>::value,
+                void*>::type = 0)
         {
             boost::unordered::detail::destroy(p);
         }