diff --git a/src/logging.cpp b/src/logging.cpp
index bcdb514c75..f53240ca8d 100644
--- a/src/logging.cpp
+++ b/src/logging.cpp
@@ -1,267 +1,264 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2018 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <logging.h>
 
 #include <util.h>
 #include <utiltime.h>
 
 bool fLogIPs = DEFAULT_LOGIPS;
 const char *const DEFAULT_DEBUGLOGFILE = "debug.log";
 
 /**
  * NOTE: the logger instance is leaked on exit. This is ugly, but will be
  * cleaned up by the OS/libc. Defining a logger as a global object doesn't work
  * since the order of destruction of static/global objects is undefined.
  * Consider if the logger gets destroyed, and then some later destructor calls
  * LogPrintf, maybe indirectly, and you get a core dump at shutdown trying to
  * access the logger. When the shutdown sequence is fully audited and tested,
  * explicit destruction of these objects can be implemented by changing this
  * from a raw pointer to a std::unique_ptr.
  *
  * This method of initialization was originally introduced in
  * ee3374234c60aba2cc4c5cd5cac1c0aefc2d817c.
  */
 BCLog::Logger &GetLogger() {
     static BCLog::Logger *const logger = new BCLog::Logger();
     return *logger;
 }
 
 static int FileWriteStr(const std::string &str, FILE *fp) {
     return fwrite(str.data(), 1, str.size(), fp);
 }
 
 fs::path BCLog::Logger::GetDebugLogPath() {
     fs::path logfile(gArgs.GetArg("-debuglogfile", DEFAULT_DEBUGLOGFILE));
     return AbsPathForConfigVal(logfile);
 }
 
 bool BCLog::Logger::OpenDebugLog() {
     std::lock_guard<std::mutex> scoped_lock(m_file_mutex);
 
     assert(m_fileout == nullptr);
     fs::path pathDebug = GetDebugLogPath();
 
     m_fileout = fsbridge::fopen(pathDebug, "a");
     if (!m_fileout) {
         return false;
     }
 
     // Unbuffered.
     setbuf(m_fileout, nullptr);
     // Dump buffered messages from before we opened the log.
     while (!m_msgs_before_open.empty()) {
         FileWriteStr(m_msgs_before_open.front(), m_fileout);
         m_msgs_before_open.pop_front();
     }
 
     return true;
 }
 
 struct CLogCategoryDesc {
     BCLog::LogFlags flag;
     std::string category;
 };
 
 const CLogCategoryDesc LogCategories[] = {
     {BCLog::NONE, "0"},
     {BCLog::NONE, "none"},
     {BCLog::NET, "net"},
     {BCLog::TOR, "tor"},
     {BCLog::MEMPOOL, "mempool"},
     {BCLog::HTTP, "http"},
     {BCLog::BENCH, "bench"},
     {BCLog::ZMQ, "zmq"},
     {BCLog::DB, "db"},
     {BCLog::RPC, "rpc"},
     {BCLog::ESTIMATEFEE, "estimatefee"},
     {BCLog::ADDRMAN, "addrman"},
     {BCLog::SELECTCOINS, "selectcoins"},
     {BCLog::REINDEX, "reindex"},
     {BCLog::CMPCTBLOCK, "cmpctblock"},
     {BCLog::RAND, "rand"},
     {BCLog::PRUNE, "prune"},
     {BCLog::PROXY, "proxy"},
     {BCLog::MEMPOOLREJ, "mempoolrej"},
     {BCLog::LIBEVENT, "libevent"},
     {BCLog::COINDB, "coindb"},
     {BCLog::QT, "qt"},
     {BCLog::LEVELDB, "leveldb"},
     {BCLog::ALL, "1"},
     {BCLog::ALL, "all"},
 };
 
 bool GetLogCategory(BCLog::LogFlags &flag, const std::string &str) {
     if (str == "") {
         flag = BCLog::ALL;
         return true;
     }
     for (const CLogCategoryDesc &category_desc : LogCategories) {
         if (category_desc.category == str) {
             flag = category_desc.flag;
             return true;
         }
     }
     return false;
 }
 
 std::string ListLogCategories() {
     std::string ret;
     int outcount = 0;
     for (const CLogCategoryDesc &category_desc : LogCategories) {
         // Omit the special cases.
         if (category_desc.flag != BCLog::NONE &&
             category_desc.flag != BCLog::ALL) {
             if (outcount != 0) {
                 ret += ", ";
             }
             ret += category_desc.category;
             outcount++;
         }
     }
     return ret;
 }
 
 BCLog::Logger::~Logger() {
     if (m_fileout) {
         fclose(m_fileout);
     }
 }
 
 std::string BCLog::Logger::LogTimestampStr(const std::string &str) {
     std::string strStamped;
 
     if (!m_log_timestamps) {
         return str;
     }
 
     if (m_started_new_line) {
         int64_t nTimeMicros = GetTimeMicros();
         strStamped = FormatISO8601DateTime(nTimeMicros / 1000000);
         if (m_log_time_micros) {
             strStamped.pop_back();
             strStamped += strprintf(".%06dZ", nTimeMicros % 1000000);
         }
         int64_t mocktime = GetMockTime();
         if (mocktime) {
             strStamped +=
                 " (mocktime: " + FormatISO8601DateTime(mocktime) + ")";
         }
         strStamped += ' ' + str;
     } else {
         strStamped = str;
     }
 
     if (!str.empty() && str[str.size() - 1] == '\n') {
         m_started_new_line = true;
     } else {
         m_started_new_line = false;
     }
 
     return strStamped;
 }
 
-int BCLog::Logger::LogPrintStr(const std::string &str) {
-    // Returns total number of characters written.
-    int ret = 0;
-
+void BCLog::Logger::LogPrintStr(const std::string &str) {
     std::string strTimestamped = LogTimestampStr(str);
 
     if (m_print_to_console) {
         // Print to console.
-        ret = fwrite(strTimestamped.data(), 1, strTimestamped.size(), stdout);
+        fwrite(strTimestamped.data(), 1, strTimestamped.size(), stdout);
         fflush(stdout);
     } else if (m_print_to_file) {
         std::lock_guard<std::mutex> scoped_lock(m_file_mutex);
 
         // Buffer if we haven't opened the log yet.
         if (m_fileout == nullptr) {
-            ret = strTimestamped.length();
             m_msgs_before_open.push_back(strTimestamped);
         } else {
             // Reopen the log file, if requested.
             if (m_reopen_file) {
                 m_reopen_file = false;
                 fs::path pathDebug = GetDebugLogPath();
-                if (fsbridge::freopen(pathDebug, "a", m_fileout) != nullptr) {
-                    // unbuffered.
-                    setbuf(m_fileout, nullptr);
+                m_fileout = fsbridge::freopen(pathDebug, "a", m_fileout);
+                if (!m_fileout) {
+                    return;
                 }
+                // unbuffered.
+                setbuf(m_fileout, nullptr);
             }
 
-            ret = FileWriteStr(strTimestamped, m_fileout);
+            FileWriteStr(strTimestamped, m_fileout);
         }
     }
-    return ret;
 }
 
 void BCLog::Logger::ShrinkDebugFile() {
     // Amount of debug.log to save at end when shrinking (must fit in memory)
     constexpr size_t RECENT_DEBUG_HISTORY_SIZE = 10 * 1000000;
     // Scroll debug.log if it's getting too big.
     fs::path pathLog = GetDebugLogPath();
     FILE *file = fsbridge::fopen(pathLog, "r");
     // If debug.log file is more than 10% bigger the RECENT_DEBUG_HISTORY_SIZE
     // trim it down by saving only the last RECENT_DEBUG_HISTORY_SIZE bytes.
     if (file &&
         fs::file_size(pathLog) > 11 * (RECENT_DEBUG_HISTORY_SIZE / 10)) {
         // Restart the file with some of the end.
         std::vector<char> vch(RECENT_DEBUG_HISTORY_SIZE, 0);
         fseek(file, -((long)vch.size()), SEEK_END);
         int nBytes = fread(vch.data(), 1, vch.size(), file);
         fclose(file);
 
         file = fsbridge::fopen(pathLog, "w");
         if (file) {
             fwrite(vch.data(), 1, nBytes, file);
             fclose(file);
         }
     } else if (file != nullptr) {
         fclose(file);
     }
 }
 
 void BCLog::Logger::EnableCategory(LogFlags category) {
     m_categories |= category;
 }
 
 bool BCLog::Logger::EnableCategory(const std::string &str) {
     BCLog::LogFlags flag;
     if (!GetLogCategory(flag, str)) {
         return false;
     }
     EnableCategory(flag);
     return true;
 }
 
 void BCLog::Logger::DisableCategory(LogFlags category) {
     m_categories &= ~category;
 }
 
 bool BCLog::Logger::DisableCategory(const std::string &str) {
     BCLog::LogFlags flag;
     if (!GetLogCategory(flag, str)) {
         return false;
     }
     DisableCategory(flag);
     return true;
 }
 
 bool BCLog::Logger::WillLogCategory(LogFlags category) const {
     // ALL is not meant to be used as a logging category, but only as a mask
     // representing all categories.
     if (category == BCLog::NONE || category == BCLog::ALL) {
         LogPrintf("Error trying to log using a category mask instead of an "
                   "explicit category.\n");
         return true;
     }
 
     return (m_categories.load(std::memory_order_relaxed) & category) != 0;
 }
 
 bool BCLog::Logger::DefaultShrinkDebugFile() const {
     return m_categories != BCLog::NONE;
 }
diff --git a/src/logging.h b/src/logging.h
index a416b14204..717b07f905 100644
--- a/src/logging.h
+++ b/src/logging.h
@@ -1,153 +1,153 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2018 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_LOGGING_H
 #define BITCOIN_LOGGING_H
 
 #include <fs.h>
 #include <tinyformat.h>
 
 #include <atomic>
 #include <cstdint>
 #include <list>
 #include <mutex>
 #include <string>
 
 static const bool DEFAULT_LOGTIMEMICROS = false;
 static const bool DEFAULT_LOGIPS = false;
 static const bool DEFAULT_LOGTIMESTAMPS = true;
 
 extern bool fLogIPs;
 extern const char *const DEFAULT_DEBUGLOGFILE;
 
 namespace BCLog {
 
 enum LogFlags : uint32_t {
     NONE = 0,
     NET = (1 << 0),
     TOR = (1 << 1),
     MEMPOOL = (1 << 2),
     HTTP = (1 << 3),
     BENCH = (1 << 4),
     ZMQ = (1 << 5),
     DB = (1 << 6),
     RPC = (1 << 7),
     ESTIMATEFEE = (1 << 8),
     ADDRMAN = (1 << 9),
     SELECTCOINS = (1 << 10),
     REINDEX = (1 << 11),
     CMPCTBLOCK = (1 << 12),
     RAND = (1 << 13),
     PRUNE = (1 << 14),
     PROXY = (1 << 15),
     MEMPOOLREJ = (1 << 16),
     LIBEVENT = (1 << 17),
     COINDB = (1 << 18),
     QT = (1 << 19),
     LEVELDB = (1 << 20),
     ALL = ~uint32_t(0),
 };
 
 class Logger {
 private:
     FILE *m_fileout = nullptr;
     std::mutex m_file_mutex;
     std::list<std::string> m_msgs_before_open;
 
     /**
      * m_started_new_line is a state variable that will suppress printing of the
      * timestamp when multiple calls are made that don't end in a newline.
      */
     std::atomic_bool m_started_new_line{true};
 
     /**
      * Log categories bitfield. Leveldb/libevent need special handling if their
      * flags are changed at runtime.
      */
     std::atomic<uint32_t> m_categories{0};
 
     std::string LogTimestampStr(const std::string &str);
 
 public:
     bool m_print_to_console = false;
     bool m_print_to_file = true;
 
     bool m_log_timestamps = DEFAULT_LOGTIMESTAMPS;
     bool m_log_time_micros = DEFAULT_LOGTIMEMICROS;
 
     std::atomic<bool> m_reopen_file{false};
 
     ~Logger();
 
     /** Send a string to the log output */
-    int LogPrintStr(const std::string &str);
+    void LogPrintStr(const std::string &str);
 
     fs::path GetDebugLogPath();
     bool OpenDebugLog();
     void ShrinkDebugFile();
 
     void EnableCategory(LogFlags category);
     bool EnableCategory(const std::string &str);
     void DisableCategory(LogFlags category);
     bool DisableCategory(const std::string &str);
 
     /** Return true if log accepts specified category */
     bool WillLogCategory(LogFlags category) const;
 
     /** Default for whether ShrinkDebugFile should be run */
     bool DefaultShrinkDebugFile() const;
 };
 
 } // namespace BCLog
 
 BCLog::Logger &GetLogger();
 
 /** Return true if log accepts specified category */
 static inline bool LogAcceptCategory(BCLog::LogFlags category) {
     return GetLogger().WillLogCategory(category);
 }
 
 /** Returns a string with the supported log categories */
 std::string ListLogCategories();
 
 /** Return true if str parses as a log category and set the flag */
 bool GetLogCategory(BCLog::LogFlags &flag, const std::string &str);
 
 // Be conservative when using LogPrintf/error or other things which
 // unconditionally log to debug.log! It should not be the case that an inbound
 // peer can fill up a users disk with debug.log entries.
 
 static inline void MarkUsed() {}
 template <typename T, typename... Args>
 static inline void MarkUsed(const T &t, const Args &... args) {
     (void)t;
     MarkUsed(args...);
 }
 
 #ifdef USE_COVERAGE
 #define LogPrintf(...)                                                         \
     do {                                                                       \
         MarkUsed(__VA_ARGS__);                                                 \
     } while (0)
 #define LogPrint(category, ...)                                                \
     do {                                                                       \
         MarkUsed(__VA_ARGS__);                                                 \
     } while (0)
 #else
 #define LogPrint(category, ...)                                                \
     do {                                                                       \
         if (LogAcceptCategory((category))) {                                   \
             GetLogger().LogPrintStr(tfm::format(__VA_ARGS__));                 \
         }                                                                      \
     } while (0)
 
 #define LogPrintf(...)                                                         \
     do {                                                                       \
         GetLogger().LogPrintStr(tfm::format(__VA_ARGS__));                     \
     } while (0)
 #endif
 
 #endif // BITCOIN_LOGGING_H