diff --git a/fmt/format.h b/fmt/format.h
index 37a4c24f..e93371e9 100644
--- a/fmt/format.h
+++ b/fmt/format.h
@@ -1171,17 +1171,17 @@ T &get();
 Yes &convert(fmt::ULongLong);
 No &convert(...);
 
-template<typename T, bool ENABLE_CONVERSION>
+template <typename T, bool ENABLE_CONVERSION>
 struct ConvertToIntImpl {
   enum { value = ENABLE_CONVERSION };
 };
 
-template<typename T, bool ENABLE_CONVERSION>
+template <typename T, bool ENABLE_CONVERSION>
 struct ConvertToIntImpl2 {
   enum { value = false };
 };
 
-template<typename T>
+template <typename T>
 struct ConvertToIntImpl2<T, true> {
   enum {
     // Don't convert numeric types.
@@ -1189,7 +1189,7 @@ struct ConvertToIntImpl2<T, true> {
   };
 };
 
-template<typename T>
+template <typename T>
 struct ConvertToInt {
   enum {
     enable_conversion = sizeof(fmt::internal::convert(get<T>())) == sizeof(Yes)
@@ -1206,16 +1206,16 @@ FMT_DISABLE_CONVERSION_TO_INT(float);
 FMT_DISABLE_CONVERSION_TO_INT(double);
 FMT_DISABLE_CONVERSION_TO_INT(long double);
 
-template<bool B, class T = void>
+template <bool B, class T = void>
 struct EnableIf {};
 
-template<class T>
+template <class T>
 struct EnableIf<true, T> { typedef T type; };
 
-template<bool B, class T, class F>
+template <bool B, class T, class F>
 struct Conditional { typedef T type; };
 
-template<class T, class F>
+template <class T, class F>
 struct Conditional<false, T, F> { typedef F type; };
 
 // For bcc32 which doesn't understand ! in template arguments.
diff --git a/fmt/ostream.h b/fmt/ostream.h
index 84a02d17..ef5e2efe 100644
--- a/fmt/ostream.h
+++ b/fmt/ostream.h
@@ -52,13 +52,15 @@ Yes &convert(std::ostream &);
 
 struct DummyStream : std::ostream {
   DummyStream();  // Suppress a bogus warning in MSVC.
+
   // Hide all operator<< overloads from std::ostream.
-  void operator<<(Null<>);
+  template <typename T>
+  typename EnableIf<sizeof(T) == 0>::type operator<<(const T &);
 };
 
 No &operator<<(std::ostream &, int);
 
-template<typename T>
+template <typename T>
 struct ConvertToIntImpl<T, true> {
   // Convert to int only if T doesn't have an overloaded operator<<.
   enum {
diff --git a/test/ostream-test.cc b/test/ostream-test.cc
index 4081b43f..486981bc 100644
--- a/test/ostream-test.cc
+++ b/test/ostream-test.cc
@@ -172,3 +172,18 @@ TEST(OStreamTest, WriteToOStreamMaxSize) {
   } while (size != 0);
   fmt::internal::write(os, w);
 }
+
+struct ConvertibleToInt {
+  template <typename ValueType>
+  operator ValueType() const {
+    return 0;
+  }
+
+  friend std::ostream &operator<<(std::ostream &o, ConvertibleToInt) {
+    return o << "foo";
+  }
+};
+
+TEST(FormatTest, FormatConvertibleToInt) {
+  EXPECT_EQ("foo", fmt::format("{}", ConvertibleToInt()));
+}