diff --git a/Source/Core/Core/IOS/Network/IP/Top.cpp b/Source/Core/Core/IOS/Network/IP/Top.cpp
diff --git a/Source/Core/Core/IOS/Network/KD/NWC24Config.cpp b/Source/Core/Core/IOS/Network/KD/NWC24Config.cpp
@@ -30,7 +30,7 @@ void NWC24Config::ReadConfig()
     {
       const s32 config_error = CheckNwc24Config();
       if (config_error)
-        ERROR_LOG(IOS_WC24, "There is an error in the config for for WC24: %d", config_error);
+        ERROR_LOG_FMT(IOS_WC24, "There is an error in the config for for WC24: {}", config_error);
 
       return;
     }
@@ -44,7 +44,7 @@ void NWC24Config::WriteConfig() const
   m_fs->CreateFullPath(PID_KD, PID_KD, CONFIG_PATH, 0, public_modes);
   const auto file = m_fs->CreateAndOpenFile(PID_KD, PID_KD, CONFIG_PATH, public_modes);
   if (!file || !file->Write(&m_data, 1))
-    ERROR_LOG(IOS_WC24, "Failed to open or write WC24 config file");
+    ERROR_LOG_FMT(IOS_WC24, "Failed to open or write WC24 config file");
 }
 
 void NWC24Config::ResetConfig()
@@ -93,21 +93,21 @@ s32 NWC24Config::CheckNwc24Config() const
   // 'WcCf' magic
   if (Magic() != 0x57634366)
   {
-    ERROR_LOG(IOS_WC24, "Magic mismatch");
+    ERROR_LOG_FMT(IOS_WC24, "Magic mismatch");
     return -14;
   }
 
   const u32 checksum = CalculateNwc24ConfigChecksum();
-  DEBUG_LOG(IOS_WC24, "Checksum: %X", checksum);
+  DEBUG_LOG_FMT(IOS_WC24, "Checksum: {:X}", checksum);
   if (Checksum() != checksum)
   {
-    ERROR_LOG(IOS_WC24, "Checksum mismatch expected %X and got %X", checksum, Checksum());
+    ERROR_LOG_FMT(IOS_WC24, "Checksum mismatch expected {:X} and got {:X}", checksum, Checksum());
     return -14;
   }
 
   if (IdGen() > 0x1F)
   {
-    ERROR_LOG(IOS_WC24, "Id gen error");
+    ERROR_LOG_FMT(IOS_WC24, "Id gen error");
     return -14;
   }
 

diff --git a/Source/Core/Core/IOS/Network/KD/NetKDRequest.cpp b/Source/Core/Core/IOS/Network/KD/NetKDRequest.cpp
@@ -39,47 +39,47 @@ IPCCommandResult NetKDRequest::IOCtl(const IOCtlRequest& request)
   {
   case IOCTL_NWC24_SUSPEND_SCHEDULAR:
     // NWC24iResumeForCloseLib  from NWC24SuspendScheduler (Input: none, Output: 32 bytes)
-    INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_SUSPEND_SCHEDULAR - NI");
+    INFO_LOG_FMT(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_SUSPEND_SCHEDULAR - NI");
     WriteReturnValue(0, request.buffer_out);  // no error
     break;
 
   case IOCTL_NWC24_EXEC_TRY_SUSPEND_SCHEDULAR:  // NWC24iResumeForCloseLib
-    INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_EXEC_TRY_SUSPEND_SCHEDULAR - NI");
+    INFO_LOG_FMT(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_EXEC_TRY_SUSPEND_SCHEDULAR - NI");
     break;
 
   case IOCTL_NWC24_EXEC_RESUME_SCHEDULAR:  // NWC24iResumeForCloseLib
-    INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_EXEC_RESUME_SCHEDULAR - NI");
+    INFO_LOG_FMT(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_EXEC_RESUME_SCHEDULAR - NI");
     WriteReturnValue(0, request.buffer_out);  // no error
     break;
 
   case IOCTL_NWC24_STARTUP_SOCKET:  // NWC24iStartupSocket
     WriteReturnValue(0, request.buffer_out);
     Memory::Write_U32(0, request.buffer_out + 4);
     return_value = 0;
-    INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_STARTUP_SOCKET - NI");
+    INFO_LOG_FMT(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_STARTUP_SOCKET - NI");
     break;
 
   case IOCTL_NWC24_CLEANUP_SOCKET:
-    INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_CLEANUP_SOCKET");
+    INFO_LOG_FMT(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_CLEANUP_SOCKET");
     WiiSockMan::GetInstance().Clean();
     break;
 
   case IOCTL_NWC24_LOCK_SOCKET:  // WiiMenu
-    INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_LOCK_SOCKET - NI");
+    INFO_LOG_FMT(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_LOCK_SOCKET - NI");
     break;
 
   case IOCTL_NWC24_UNLOCK_SOCKET:
-    INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_UNLOCK_SOCKET - NI");
+    INFO_LOG_FMT(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_UNLOCK_SOCKET - NI");
     break;
 
   case IOCTL_NWC24_REQUEST_REGISTER_USER_ID:
-    INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_REGISTER_USER_ID");
+    INFO_LOG_FMT(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_REGISTER_USER_ID");
     WriteReturnValue(0, request.buffer_out);
     Memory::Write_U32(0, request.buffer_out + 4);
     break;
 
   case IOCTL_NWC24_REQUEST_GENERATED_USER_ID:  // (Input: none, Output: 32 bytes)
-    INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_GENERATED_USER_ID");
+    INFO_LOG_FMT(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_GENERATED_USER_ID");
     if (config.CreationStage() == NWC24::NWC24Config::NWC24_IDCS_INITIAL)
     {
       const std::string settings_file_path =
@@ -133,11 +133,11 @@ IPCCommandResult NetKDRequest::IOCtl(const IOCtlRequest& request)
     break;
 
   case IOCTL_NWC24_GET_SCHEDULAR_STAT:
-    INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_GET_SCHEDULAR_STAT - NI");
+    INFO_LOG_FMT(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_GET_SCHEDULAR_STAT - NI");
     break;
 
   case IOCTL_NWC24_SAVE_MAIL_NOW:
-    INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_SAVE_MAIL_NOW - NI");
+    INFO_LOG_FMT(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_SAVE_MAIL_NOW - NI");
     break;
 
   case IOCTL_NWC24_REQUEST_SHUTDOWN:
@@ -146,11 +146,11 @@ IPCCommandResult NetKDRequest::IOCtl(const IOCtlRequest& request)
         request.buffer_out == 0 || request.buffer_out % 4 != 0 || request.buffer_out_size < 4)
     {
       return_value = IPC_EINVAL;
-      ERROR_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_SHUTDOWN = IPC_EINVAL");
+      ERROR_LOG_FMT(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_SHUTDOWN = IPC_EINVAL");
       break;
     }
 
-    INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_SHUTDOWN");
+    INFO_LOG_FMT(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_SHUTDOWN");
     [[maybe_unused]] const u32 event = Memory::Read_U32(request.buffer_in);
     // TODO: Advertise shutdown event
     // TODO: Shutdown USB keyboard LEDs if event == 3

diff --git a/Source/Core/Core/IOS/Network/KD/NetKDTime.cpp b/Source/Core/Core/IOS/Network/KD/NetKDTime.cpp
@@ -4,7 +4,6 @@
 
 #include "Core/IOS/Network/KD/NetKDTime.h"
 
-#include <cinttypes>
 #include <string>
 
 #include "Common/CommonTypes.h"
@@ -32,7 +31,7 @@ IPCCommandResult NetKDTime::IOCtl(const IOCtlRequest& request)
   {
     const u64 adjusted_utc = GetAdjustedUTC();
     Memory::Write_U64(adjusted_utc, request.buffer_out + 4);
-    INFO_LOG(IOS_WC24, "IOCTL_NW24_GET_UNIVERSAL_TIME = %d, time = %" PRIu64, result, adjusted_utc);
+    INFO_LOG_FMT(IOS_WC24, "IOCTL_NW24_GET_UNIVERSAL_TIME = {}, time = {}", result, adjusted_utc);
   }
   break;
 
@@ -41,29 +40,28 @@ IPCCommandResult NetKDTime::IOCtl(const IOCtlRequest& request)
     const u64 adjusted_utc = Memory::Read_U64(request.buffer_in);
     SetAdjustedUTC(adjusted_utc);
     update_misc = Memory::Read_U32(request.buffer_in + 8);
-    INFO_LOG(IOS_WC24, "IOCTL_NW24_SET_UNIVERSAL_TIME (%" PRIu64 ", %u) = %d", adjusted_utc,
-             update_misc, result);
+    INFO_LOG_FMT(IOS_WC24, "IOCTL_NW24_SET_UNIVERSAL_TIME ({}, {}) = {}", adjusted_utc, update_misc,
+                 result);
   }
   break;
 
   case IOCTL_NW24_SET_RTC_COUNTER:
     rtc = Memory::Read_U32(request.buffer_in);
     update_misc = Memory::Read_U32(request.buffer_in + 4);
-    INFO_LOG(IOS_WC24, "IOCTL_NW24_SET_RTC_COUNTER (%" PRIu64 ", %u) = %d", rtc, update_misc,
-             result);
+    INFO_LOG_FMT(IOS_WC24, "IOCTL_NW24_SET_RTC_COUNTER ({}, {}) = {}", rtc, update_misc, result);
     break;
 
   case IOCTL_NW24_GET_TIME_DIFF:
   {
     const u64 time_diff = GetAdjustedUTC() - rtc;
     Memory::Write_U64(time_diff, request.buffer_out + 4);
-    INFO_LOG(IOS_WC24, "IOCTL_NW24_GET_TIME_DIFF = %d, time_diff = %" PRIu64, result, time_diff);
+    INFO_LOG_FMT(IOS_WC24, "IOCTL_NW24_GET_TIME_DIFF = {}, time_diff = {}", result, time_diff);
   }
   break;
 
   case IOCTL_NW24_UNIMPLEMENTED:
     result = -9;
-    INFO_LOG(IOS_WC24, "IOCTL_NW24_UNIMPLEMENTED = %d", result);
+    INFO_LOG_FMT(IOS_WC24, "IOCTL_NW24_UNIMPLEMENTED = {}", result);
     break;
 
   default:

diff --git a/Source/Core/Core/IOS/Network/MACUtils.cpp b/Source/Core/Core/IOS/Network/MACUtils.cpp
@@ -39,14 +39,14 @@ Common::MACAddress GetMACAddress()
     SaveMACAddress(mac.value());
     if (!wireless_mac.empty())
     {
-      ERROR_LOG(IOS_NET,
-                "The MAC provided (%s) is invalid. We have "
-                "generated another one for you.",
-                Common::MacAddressToString(mac.value()).c_str());
+      ERROR_LOG_FMT(IOS_NET,
+                    "The MAC provided ({}) is invalid. We have "
+                    "generated another one for you.",
+                    Common::MacAddressToString(mac.value()));
     }
   }
 
-  INFO_LOG(IOS_NET, "Using MAC address: %s", Common::MacAddressToString(mac.value()).c_str());
+  INFO_LOG_FMT(IOS_NET, "Using MAC address: {}", Common::MacAddressToString(mac.value()));
   return mac.value();
 }
 }  // namespace IOS::Net
diff --git a/Source/Core/Core/IOS/Network/NCD/Manage.cpp b/Source/Core/Core/IOS/Network/NCD/Manage.cpp
@@ -36,45 +36,45 @@ IPCCommandResult NetNCDManage::IOCtlV(const IOCtlVRequest& request)
     break;
 
   case IOCTLV_NCD_GETCONFIG:
-    INFO_LOG(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_GETCONFIG");
+    INFO_LOG_FMT(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_GETCONFIG");
     config.WriteToMem(request.io_vectors.at(0).address);
     common_vector = 1;
     break;
 
   case IOCTLV_NCD_SETCONFIG:
-    INFO_LOG(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_SETCONFIG");
+    INFO_LOG_FMT(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_SETCONFIG");
     config.ReadFromMem(request.in_vectors.at(0).address);
     break;
 
   case IOCTLV_NCD_READCONFIG:
-    INFO_LOG(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_READCONFIG");
+    INFO_LOG_FMT(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_READCONFIG");
     config.ReadConfig(m_ios.GetFS().get());
     config.WriteToMem(request.io_vectors.at(0).address);
     break;
 
   case IOCTLV_NCD_WRITECONFIG:
-    INFO_LOG(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_WRITECONFIG");
+    INFO_LOG_FMT(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_WRITECONFIG");
     config.ReadFromMem(request.in_vectors.at(0).address);
     config.WriteConfig(m_ios.GetFS().get());
     break;
 
   case IOCTLV_NCD_GETLINKSTATUS:
-    INFO_LOG(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_GETLINKSTATUS");
+    INFO_LOG_FMT(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_GETLINKSTATUS");
     // Always connected
     Memory::Write_U32(Net::ConnectionSettings::LINK_WIRED, request.io_vectors.at(0).address + 4);
     break;
 
   case IOCTLV_NCD_GETWIRELESSMACADDRESS:
   {
-    INFO_LOG(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_GETWIRELESSMACADDRESS");
+    INFO_LOG_FMT(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_GETWIRELESSMACADDRESS");
 
     const Common::MACAddress address = IOS::Net::GetMACAddress();
     Memory::CopyToEmu(request.io_vectors.at(1).address, address.data(), address.size());
     break;
   }
 
   default:
-    INFO_LOG(IOS_NET, "NET_NCD_MANAGE IOCtlV: %#x", request.request);
+    INFO_LOG_FMT(IOS_NET, "NET_NCD_MANAGE IOCtlV: {:#x}", request.request);
     break;
   }
 

diff --git a/Source/Core/Core/IOS/Network/NCD/WiiNetConfig.cpp b/Source/Core/Core/IOS/Network/NCD/WiiNetConfig.cpp
@@ -36,7 +36,7 @@ void WiiNetConfig::WriteConfig(FS::FileSystem* fs) const
   fs->CreateFullPath(PID_NCD, PID_NCD, CONFIG_PATH, 0, public_modes);
   const auto file = fs->CreateAndOpenFile(PID_NCD, PID_NCD, CONFIG_PATH, public_modes);
   if (!file || !file->Write(&m_data, 1))
-    ERROR_LOG(IOS_NET, "Failed to write config");
+    ERROR_LOG_FMT(IOS_NET, "Failed to write config");
 }
 
 void WiiNetConfig::ResetConfig(FS::FileSystem* fs)

diff --git a/Source/Core/Core/IOS/Network/SSL.cpp b/Source/Core/Core/IOS/Network/SSL.cpp
diff --git a/Source/Core/Core/IOS/Network/Socket.cpp b/Source/Core/Core/IOS/Network/Socket.cpp
@@ -63,7 +63,7 @@ static s32 TranslateErrorCode(s32 native_error, bool is_rw)
   switch (native_error)
   {
   case ERRORCODE(EMSGSIZE):
-    ERROR_LOG(IOS_NET, "Find out why this happened, looks like PEEK failure?");
+    ERROR_LOG_FMT(IOS_NET, "Find out why this happened, looks like PEEK failure?");
     return -1;  // Should be -SO_EMSGSIZE
   case EITHER(WSAENOTSOCK, EBADF):
     return -SO_EBADF;
@@ -100,12 +100,12 @@ static s32 TranslateErrorCode(s32 native_error, bool is_rw)
 }
 
 // Don't use string! (see https://github.com/dolphin-emu/dolphin/pull/3143)
-s32 WiiSockMan::GetNetErrorCode(s32 ret, const char* caller, bool isRW)
+s32 WiiSockMan::GetNetErrorCode(s32 ret, std::string_view caller, bool is_rw)
 {
 #ifdef _WIN32
-  s32 errorCode = WSAGetLastError();
+  s32 error_code = WSAGetLastError();
 #else
-  s32 errorCode = errno;
+  s32 error_code = errno;
 #endif
 
   if (ret >= 0)
@@ -114,13 +114,13 @@ s32 WiiSockMan::GetNetErrorCode(s32 ret, const char* caller, bool isRW)
     return ret;
   }
 
-  ERROR_LOG(IOS_NET, "%s failed with error %d: %s, ret= %d", caller, errorCode,
-            DecodeError(errorCode), ret);
+  ERROR_LOG_FMT(IOS_NET, "{} failed with error {}: {}, ret= {}", caller, error_code,
+                DecodeError(error_code), ret);
 
-  s32 ReturnValue = TranslateErrorCode(errorCode, isRW);
-  WiiSockMan::GetInstance().SetLastNetError(ReturnValue);
+  const s32 return_value = TranslateErrorCode(error_code, is_rw);
+  WiiSockMan::GetInstance().SetLastNetError(return_value);
 
-  return ReturnValue;
+  return return_value;
 }
 
 WiiSocket::~WiiSocket()
@@ -248,10 +248,10 @@ s32 WiiSocket::FCntl(u32 cmd, u32 arg)
   }
   else
   {
-    ERROR_LOG(IOS_NET, "SO_FCNTL unknown command");
+    ERROR_LOG_FMT(IOS_NET, "SO_FCNTL unknown command");
   }
 
-  INFO_LOG(IOS_NET, "IOCTL_SO_FCNTL(%08x, %08X, %08X)", wii_fd, cmd, arg);
+  INFO_LOG_FMT(IOS_NET, "IOCTL_SO_FCNTL({:08x}, {:08X}, {:08X})", wii_fd, cmd, arg);
 
   return ret;
 }
@@ -285,8 +285,8 @@ void WiiSocket::Update(bool read, bool write, bool except)
         int ret = bind(fd, (sockaddr*)&local_name, sizeof(local_name));
         ReturnValue = WiiSockMan::GetNetErrorCode(ret, "SO_BIND", false);
 
-        INFO_LOG(IOS_NET, "IOCTL_SO_BIND (%08X, %s:%d) = %d", wii_fd,
-                 inet_ntoa(local_name.sin_addr), Common::swap16(local_name.sin_port), ret);
+        INFO_LOG_FMT(IOS_NET, "IOCTL_SO_BIND ({:08X}, {}:{}) = {}", wii_fd,
+                     inet_ntoa(local_name.sin_addr), Common::swap16(local_name.sin_port), ret);
         break;
       }
       case IOCTL_SO_CONNECT:
@@ -298,8 +298,8 @@ void WiiSocket::Update(bool read, bool write, bool except)
         int ret = connect(fd, (sockaddr*)&local_name, sizeof(local_name));
         ReturnValue = WiiSockMan::GetNetErrorCode(ret, "SO_CONNECT", false);
 
-        INFO_LOG(IOS_NET, "IOCTL_SO_CONNECT (%08x, %s:%d) = %d", wii_fd,
-                 inet_ntoa(local_name.sin_addr), Common::swap16(local_name.sin_port), ret);
+        INFO_LOG_FMT(IOS_NET, "IOCTL_SO_CONNECT ({:08x}, {}:{}) = {}", wii_fd,
+                     inet_ntoa(local_name.sin_addr), Common::swap16(local_name.sin_port), ret);
         break;
       }
       case IOCTL_SO_ACCEPT:
@@ -381,12 +381,12 @@ void WiiSocket::Update(bool read, bool write, bool except)
           case IOCTLV_NET_SSL_DOHANDSHAKE:
           {
             mbedtls_ssl_context* ctx = &Device::NetSSL::_SSL[sslID].ctx;
-            int ret = mbedtls_ssl_handshake(ctx);
-            if (ret)
+            const int ret = mbedtls_ssl_handshake(ctx);
+            if (ret != 0)
             {
               char error_buffer[256] = "";
               mbedtls_strerror(ret, error_buffer, sizeof(error_buffer));
-              ERROR_LOG(IOS_SSL, "IOCTLV_NET_SSL_DOHANDSHAKE: %s", error_buffer);
+              ERROR_LOG_FMT(IOS_SSL, "IOCTLV_NET_SSL_DOHANDSHAKE: {}", error_buffer);
             }
             switch (ret)
             {
@@ -408,8 +408,8 @@ void WiiSocket::Update(bool read, bool write, bool except)
               char error_buffer[256] = "";
               int res = mbedtls_ssl_get_verify_result(ctx);
               mbedtls_x509_crt_verify_info(error_buffer, sizeof(error_buffer), "", res);
-              ERROR_LOG(IOS_SSL, "MBEDTLS_ERR_X509_CERT_VERIFY_FAILED (verify_result = %d): %s",
-                        res, error_buffer);
+              ERROR_LOG_FMT(IOS_SSL, "MBEDTLS_ERR_X509_CERT_VERIFY_FAILED (verify_result = {}): {}",
+                            res, error_buffer);
 
               if (res & MBEDTLS_X509_BADCERT_CN_MISMATCH)
                 res = SSL_ERR_VCOMMONNAME;
@@ -447,12 +447,12 @@ void WiiSocket::Update(bool read, bool write, bool except)
               }
             }
 
-            INFO_LOG(IOS_SSL,
-                     "IOCTLV_NET_SSL_DOHANDSHAKE = (%d) "
-                     "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
-                     "BufferOut: (%08x, %i), BufferOut2: (%08x, %i)",
-                     ret, BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferOut,
-                     BufferOutSize, BufferOut2, BufferOutSize2);
+            INFO_LOG_FMT(IOS_SSL,
+                         "IOCTLV_NET_SSL_DOHANDSHAKE = ({}) "
+                         "BufferIn: ({:08x}, {}), BufferIn2: ({:08x}, {}), "
+                         "BufferOut: ({:08x}, {}), BufferOut2: ({:08x}, {})",
+                         ret, BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferOut,
+                         BufferOutSize, BufferOut2, BufferOutSize2);
             break;
           }
           case IOCTLV_NET_SSL_WRITE:
@@ -564,18 +564,19 @@ void WiiSocket::Update(bool read, bool write, bool except)
             WiiSockMan::Convert(*wii_name, local_name);
           }
 
-          int ret = sendto(fd, data, BufferInSize, flags,
-                           has_destaddr ? (struct sockaddr*)&local_name : nullptr,
-                           has_destaddr ? sizeof(sockaddr) : 0);
+          const int ret = sendto(fd, data, BufferInSize, flags,
+                                 has_destaddr ? (struct sockaddr*)&local_name : nullptr,
+                                 has_destaddr ? sizeof(sockaddr) : 0);
           ReturnValue = WiiSockMan::GetNetErrorCode(ret, "SO_SENDTO", true);
 
-          INFO_LOG(IOS_NET,
-                   "%s = %d Socket: %08x, BufferIn: (%08x, %i), BufferIn2: (%08x, %i), %u.%u.%u.%u",
-                   has_destaddr ? "IOCTLV_SO_SENDTO " : "IOCTLV_SO_SEND ", ReturnValue, wii_fd,
-                   BufferIn, BufferInSize, BufferIn2, BufferInSize2,
-                   local_name.sin_addr.s_addr & 0xFF, (local_name.sin_addr.s_addr >> 8) & 0xFF,
-                   (local_name.sin_addr.s_addr >> 16) & 0xFF,
-                   (local_name.sin_addr.s_addr >> 24) & 0xFF);
+          INFO_LOG_FMT(IOS_NET,
+                       "{} = {} Socket: {:08x}, BufferIn: ({:08x}, {}), BufferIn2: ({:08x}, {}), "
+                       "{}.{}.{}.{}",
+                       has_destaddr ? "IOCTLV_SO_SENDTO " : "IOCTLV_SO_SEND ", ReturnValue, wii_fd,
+                       BufferIn, BufferInSize, BufferIn2, BufferInSize2,
+                       local_name.sin_addr.s_addr & 0xFF, (local_name.sin_addr.s_addr >> 8) & 0xFF,
+                       (local_name.sin_addr.s_addr >> 16) & 0xFF,
+                       (local_name.sin_addr.s_addr >> 24) & 0xFF);
           break;
         }
         case IOCTLV_SO_RECVFROM:
@@ -609,19 +610,19 @@ void WiiSocket::Update(bool read, bool write, bool except)
           }
 #endif
           socklen_t addrlen = sizeof(sockaddr_in);
-          int ret = recvfrom(fd, data, data_len, flags,
-                             BufferOutSize2 ? (struct sockaddr*)&local_name : nullptr,
-                             BufferOutSize2 ? &addrlen : nullptr);
+          const int ret = recvfrom(fd, data, data_len, flags,
+                                   BufferOutSize2 ? (struct sockaddr*)&local_name : nullptr,
+                                   BufferOutSize2 ? &addrlen : nullptr);
           ReturnValue =
               WiiSockMan::GetNetErrorCode(ret, BufferOutSize2 ? "SO_RECVFROM" : "SO_RECV", true);
 
-          INFO_LOG(IOS_NET,
-                   "%s(%d, %p) Socket: %08X, Flags: %08X, "
-                   "BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
-                   "BufferOut: (%08x, %i), BufferOut2: (%08x, %i)",
-                   BufferOutSize2 ? "IOCTLV_SO_RECVFROM " : "IOCTLV_SO_RECV ", ReturnValue, data,
-                   wii_fd, flags, BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferOut,
-                   BufferOutSize, BufferOut2, BufferOutSize2);
+          INFO_LOG_FMT(IOS_NET,
+                       "{}({}, {}) Socket: {:08X}, Flags: {:08X}, "
+                       "BufferIn: ({:08x}, {}), BufferIn2: ({:08x}, {}), "
+                       "BufferOut: ({:08x}, {}), BufferOut2: ({:08x}, {})",
+                       BufferOutSize2 ? "IOCTLV_SO_RECVFROM " : "IOCTLV_SO_RECV ", ReturnValue,
+                       fmt::ptr(data), wii_fd, flags, BufferIn, BufferInSize, BufferIn2,
+                       BufferInSize2, BufferOut, BufferOutSize, BufferOut2, BufferOutSize2);
 
           if (BufferOutSize2 != 0)
           {
@@ -647,10 +648,10 @@ void WiiSocket::Update(bool read, bool write, bool except)
          ReturnValue != -SO_EALREADY) ||
         (it->is_ssl && ReturnValue != SSL_ERR_WAGAIN && ReturnValue != SSL_ERR_RAGAIN))
     {
-      DEBUG_LOG(IOS_NET,
-                "IOCTL(V) Sock: %08x ioctl/v: %d returned: %d nonBlock: %d forceNonBlock: %d",
-                wii_fd, it->is_ssl ? (int)it->ssl_type : (int)it->net_type, ReturnValue, nonBlock,
-                forceNonBlock);
+      DEBUG_LOG_FMT(
+          IOS_NET, "IOCTL(V) Sock: {:08x} ioctl/v: {} returned: {} nonBlock: {} forceNonBlock: {}",
+          wii_fd, it->is_ssl ? static_cast<int>(it->ssl_type) : static_cast<int>(it->net_type),
+          ReturnValue, nonBlock, forceNonBlock);
 
       // TODO: remove the dependency on a running IOS instance.
       GetIOS()->EnqueueIPCReply(it->request, ReturnValue);
@@ -697,7 +698,7 @@ s32 WiiSockMan::AddSocket(s32 fd, bool is_rw)
     // Close host socket
     closesocket(fd);
     wii_fd = -SO_EMFILE;
-    ERROR_LOG(IOS_NET, "%s failed: Too many open sockets, ret=%d", caller, wii_fd);
+    ERROR_LOG_FMT(IOS_NET, "{} failed: Too many open sockets, ret={}", caller, wii_fd);
   }
   else
   {
@@ -708,7 +709,7 @@ s32 WiiSockMan::AddSocket(s32 fd, bool is_rw)
 #ifdef __APPLE__
     int opt_no_sigpipe = 1;
     if (setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &opt_no_sigpipe, sizeof(opt_no_sigpipe)) < 0)
-      ERROR_LOG(IOS_NET, "Failed to set SO_NOSIGPIPE on socket");
+      ERROR_LOG_FMT(IOS_NET, "Failed to set SO_NOSIGPIPE on socket");
 #endif
   }
 
@@ -883,8 +884,9 @@ void WiiSockMan::UpdatePollCommands()
               // Memory::Write_U32(ufds[i].fd, request.buffer_out + 0xc*i); //fd
               // Memory::Write_U32(events, request.buffer_out + 0xc*i + 4); //events
               Memory::Write_U32(revents, pcmd.buffer_out + 0xc * i + 8);  // revents
-              DEBUG_LOG(IOS_NET, "IOCTL_SO_POLL socket %d wevents %08X events %08X revents %08X", i,
-                        revents, pfds[i].events, pfds[i].revents);
+              DEBUG_LOG_FMT(IOS_NET,
+                            "IOCTL_SO_POLL socket {} wevents {:08X} events {:08X} revents {:08X}",
+                            i, revents, pfds[i].events, pfds[i].revents);
             }
             GetIOS()->EnqueueIPCReply(request, ret);
             return true;
@@ -932,7 +934,7 @@ s32 WiiSockMan::ConvertEvents(s32 events, ConvertDirection dir)
     }
   }
   if (unhandled_events)
-    ERROR_LOG(IOS_NET, "SO_POLL: unhandled Wii event types: %04x", unhandled_events);
+    ERROR_LOG_FMT(IOS_NET, "SO_POLL: unhandled Wii event types: {:04x}", unhandled_events);
   return converted_events;
 }
 

diff --git a/Source/Core/Core/IOS/Network/Socket.h b/Source/Core/Core/IOS/Network/Socket.h
@@ -45,6 +45,7 @@ typedef struct pollfd pollfd_t;
 #include <cstdio>
 #include <list>
 #include <string>
+#include <string_view>
 #include <unordered_map>
 #include <utility>
 
@@ -229,7 +230,7 @@ class WiiSockMan
     s64 timeout;
   };
 
-  static s32 GetNetErrorCode(s32 ret, const char* caller, bool isRW);
+  static s32 GetNetErrorCode(s32 ret, std::string_view caller, bool is_rw);
   static char* DecodeError(s32 ErrorCode);
 
   static WiiSockMan& GetInstance()
@@ -260,8 +261,8 @@ class WiiSockMan
     auto socket_entry = WiiSockets.find(sock);
     if (socket_entry == WiiSockets.end())
     {
-      ERROR_LOG(IOS_NET, "DoSock: Error, fd not found (%08x, %08X, %08X)", sock, request.address,
-                type);
+      ERROR_LOG_FMT(IOS_NET, "DoSock: Error, fd not found ({:08x}, {:08X}, {:08X})", sock,
+                    request.address, type);
       GetIOS()->EnqueueIPCReply(request, -SO_EBADF);
     }
     else

diff --git a/Source/Core/Core/IOS/SDIO/SDIOSlot0.cpp b/Source/Core/Core/IOS/SDIO/SDIOSlot0.cpp
@@ -27,7 +27,7 @@ SDIOSlot0::SDIOSlot0(Kernel& ios, const std::string& device_name)
     : Device(ios, device_name), m_sdhc_supported(HasFeature(ios.GetVersion(), Feature::SDv2))
 {
   if (!Config::Get(Config::MAIN_ALLOW_SD_WRITES))
-    INFO_LOG(IOS_SD, "Writes to SD card disabled by user");
+    INFO_LOG_FMT(IOS_SD, "Writes to SD card disabled by user");
 }
 
 void SDIOSlot0::DoState(PointerWrap& p)
@@ -65,16 +65,16 @@ void SDIOSlot0::OpenInternal()
   m_card.Open(filename, "r+b");
   if (!m_card)
   {
-    WARN_LOG(IOS_SD, "Failed to open SD Card image, trying to create a new 128 MB image...");
+    WARN_LOG_FMT(IOS_SD, "Failed to open SD Card image, trying to create a new 128 MB image...");
     if (Common::SDCardCreate(128, filename))
     {
-      INFO_LOG(IOS_SD, "Successfully created %s", filename.c_str());
+      INFO_LOG_FMT(IOS_SD, "Successfully created {}", filename);
       m_card.Open(filename, "r+b");
     }
     if (!m_card)
     {
-      ERROR_LOG(IOS_SD, "Could not open SD Card image or create a new one, are you running "
-                        "from a read-only directory?");
+      ERROR_LOG_FMT(IOS_SD, "Could not open SD Card image or create a new one, are you running "
+                            "from a read-only directory?");
     }
   }
 }
@@ -119,7 +119,7 @@ IPCCommandResult SDIOSlot0::IOCtl(const IOCtlRequest& request)
   case IOCTL_GETOCR:
     return GetOCRegister(request);
   default:
-    ERROR_LOG(IOS_SD, "Unknown SD IOCtl command (0x%08x)", request.request);
+    ERROR_LOG_FMT(IOS_SD, "Unknown SD IOCtl command ({:#010x})", request.request);
     break;
   }
 
@@ -133,7 +133,7 @@ IPCCommandResult SDIOSlot0::IOCtlV(const IOCtlVRequest& request)
   case IOCTLV_SENDCMD:
     return SendCommand(request);
   default:
-    ERROR_LOG(IOS_SD, "Unknown SD IOCtlV command 0x%08x", request.request);
+    ERROR_LOG_FMT(IOS_SD, "Unknown SD IOCtlV command {:#010x}", request.request);
     break;
   }
 
@@ -176,7 +176,7 @@ s32 SDIOSlot0::ExecuteCommand(const Request& request, u32 buffer_in, u32 buffer_
   switch (req.command)
   {
   case GO_IDLE_STATE:
-    INFO_LOG(IOS_SD, "GO_IDLE_STATE");
+    INFO_LOG_FMT(IOS_SD, "GO_IDLE_STATE");
     // Response is R1 (idle state)
     Memory::Write_U32(0x00, buffer_out);
     break;
@@ -194,7 +194,7 @@ s32 SDIOSlot0::ExecuteCommand(const Request& request, u32 buffer_in, u32 buffer_
     break;
 
   case SEND_IF_COND:
-    INFO_LOG(IOS_SD, "SEND_IF_COND");
+    INFO_LOG_FMT(IOS_SD, "SEND_IF_COND");
     // If the card can operate on the supplied voltage, the response echoes back the supply
     // voltage and the check pattern that were set in the command argument.
     // This command is used to differentiate between protocol v1 and v2.
@@ -211,7 +211,7 @@ s32 SDIOSlot0::ExecuteCommand(const Request& request, u32 buffer_in, u32 buffer_
 
   case ALL_SEND_CID:
   case SEND_CID:
-    INFO_LOG(IOS_SD, "(ALL_)SEND_CID");
+    INFO_LOG_FMT(IOS_SD, "(ALL_)SEND_CID");
     Memory::Write_U32(0x80114d1c, buffer_out);
     Memory::Write_U32(0x80080000, buffer_out + 4);
     Memory::Write_U32(0x8007b520, buffer_out + 8);
@@ -244,25 +244,25 @@ s32 SDIOSlot0::ExecuteCommand(const Request& request, u32 buffer_in, u32 buffer_
   {
     // Data address (req.arg) is in byte units in a Standard Capacity SD Memory Card
     // and in block (512 Byte) units in a High Capacity SD Memory Card.
-    INFO_LOG(IOS_SD, "%sRead %i Block(s) from 0x%08x bsize %i into 0x%08x!",
-             req.isDMA ? "DMA " : "", req.blocks, req.arg, req.bsize, req.addr);
+    INFO_LOG_FMT(IOS_SD, "{}Read {} Block(s) from {:#010x} bsize {} into {:#010x}!",
+                 req.isDMA ? "DMA " : "", req.blocks, req.arg, req.bsize, req.addr);
 
     if (m_card)
     {
-      u32 size = req.bsize * req.blocks;
-      u64 address = GetAddressFromRequest(req.arg);
+      const u32 size = req.bsize * req.blocks;
+      const u64 address = GetAddressFromRequest(req.arg);
 
       if (!m_card.Seek(address, SEEK_SET))
-        ERROR_LOG(IOS_SD, "Seek failed WTF");
+        ERROR_LOG_FMT(IOS_SD, "Seek failed WTF");
 
       if (m_card.ReadBytes(Memory::GetPointer(req.addr), size))
       {
-        DEBUG_LOG(IOS_SD, "Outbuffer size %i got %i", rw_buffer_size, size);
+        DEBUG_LOG_FMT(IOS_SD, "Outbuffer size {} got {}", rw_buffer_size, size);
       }
       else
       {
-        ERROR_LOG(IOS_SD, "Read Failed - error: %i, eof: %i", ferror(m_card.GetHandle()),
-                  feof(m_card.GetHandle()));
+        ERROR_LOG_FMT(IOS_SD, "Read Failed - error: {}, eof: {}", std::ferror(m_card.GetHandle()),
+                      std::feof(m_card.GetHandle()));
         ret = RET_FAIL;
       }
     }
@@ -274,22 +274,22 @@ s32 SDIOSlot0::ExecuteCommand(const Request& request, u32 buffer_in, u32 buffer_
   {
     // Data address (req.arg) is in byte units in a Standard Capacity SD Memory Card
     // and in block (512 Byte) units in a High Capacity SD Memory Card.
-    INFO_LOG(IOS_SD, "%sWrite %i Block(s) from 0x%08x bsize %i to offset 0x%08x!",
-             req.isDMA ? "DMA " : "", req.blocks, req.addr, req.bsize, req.arg);
+    INFO_LOG_FMT(IOS_SD, "{}Write {} Block(s) from {:#010x} bsize {} to offset {:#010x}!",
+                 req.isDMA ? "DMA " : "", req.blocks, req.addr, req.bsize, req.arg);
 
     if (m_card && SConfig::GetInstance().bEnableMemcardSdWriting &&
         Config::Get(Config::MAIN_ALLOW_SD_WRITES))
     {
-      u32 size = req.bsize * req.blocks;
-      u64 address = GetAddressFromRequest(req.arg);
+      const u32 size = req.bsize * req.blocks;
+      const u64 address = GetAddressFromRequest(req.arg);
 
       if (!m_card.Seek(address, SEEK_SET))
-        ERROR_LOG(IOS_SD, "fseeko failed WTF");
+        ERROR_LOG_FMT(IOS_SD, "fseeko failed WTF");
 
       if (!m_card.WriteBytes(Memory::GetPointer(req.addr), size))
       {
-        ERROR_LOG(IOS_SD, "Write Failed - error: %i, eof: %i", ferror(m_card.GetHandle()),
-                  feof(m_card.GetHandle()));
+        ERROR_LOG_FMT(IOS_SD, "Write Failed - error: {}, eof: {}", std::ferror(m_card.GetHandle()),
+                      std::feof(m_card.GetHandle()));
         ret = RET_FAIL;
       }
     }
@@ -298,15 +298,15 @@ s32 SDIOSlot0::ExecuteCommand(const Request& request, u32 buffer_in, u32 buffer_
     break;
 
   case EVENT_REGISTER:  // async
-    INFO_LOG(IOS_SD, "Register event %x", req.arg);
+    INFO_LOG_FMT(IOS_SD, "Register event {:x}", req.arg);
     m_event = std::make_unique<Event>(static_cast<EventType>(req.arg), request);
     ret = RET_EVENT_REGISTER;
     break;
 
   // Used to cancel an event that was already registered.
   case EVENT_UNREGISTER:
   {
-    INFO_LOG(IOS_SD, "Unregister event %x", req.arg);
+    INFO_LOG_FMT(IOS_SD, "Unregister event {:x}", req.arg);
     if (!m_event)
       return IPC_EINVAL;
     // release returns 0
@@ -318,7 +318,7 @@ s32 SDIOSlot0::ExecuteCommand(const Request& request, u32 buffer_in, u32 buffer_
   }
 
   default:
-    ERROR_LOG(IOS_SD, "Unknown SD command 0x%08x", req.command);
+    ERROR_LOG_FMT(IOS_SD, "Unknown SD command {:#010x}", req.command);
     break;
   }
 
@@ -327,14 +327,14 @@ s32 SDIOSlot0::ExecuteCommand(const Request& request, u32 buffer_in, u32 buffer_
 
 IPCCommandResult SDIOSlot0::WriteHCRegister(const IOCtlRequest& request)
 {
-  u32 reg = Memory::Read_U32(request.buffer_in);
-  u32 val = Memory::Read_U32(request.buffer_in + 16);
+  const u32 reg = Memory::Read_U32(request.buffer_in);
+  const u32 val = Memory::Read_U32(request.buffer_in + 16);
 
-  INFO_LOG(IOS_SD, "IOCTL_WRITEHCR 0x%08x - 0x%08x", reg, val);
+  INFO_LOG_FMT(IOS_SD, "IOCTL_WRITEHCR {:#010x} - {:#010x}", reg, val);
 
   if (reg >= m_registers.size())
   {
-    WARN_LOG(IOS_SD, "IOCTL_WRITEHCR out of range");
+    WARN_LOG_FMT(IOS_SD, "IOCTL_WRITEHCR out of range");
     return GetDefaultReply(IPC_SUCCESS);
   }
 
@@ -359,16 +359,16 @@ IPCCommandResult SDIOSlot0::WriteHCRegister(const IOCtlRequest& request)
 
 IPCCommandResult SDIOSlot0::ReadHCRegister(const IOCtlRequest& request)
 {
-  u32 reg = Memory::Read_U32(request.buffer_in);
+  const u32 reg = Memory::Read_U32(request.buffer_in);
 
   if (reg >= m_registers.size())
   {
-    WARN_LOG(IOS_SD, "IOCTL_READHCR out of range");
+    WARN_LOG_FMT(IOS_SD, "IOCTL_READHCR out of range");
     return GetDefaultReply(IPC_SUCCESS);
   }
 
-  u32 val = m_registers[reg];
-  INFO_LOG(IOS_SD, "IOCTL_READHCR 0x%08x - 0x%08x", reg, val);
+  const u32 val = m_registers[reg];
+  INFO_LOG_FMT(IOS_SD, "IOCTL_READHCR {:#010x} - {:#010x}", reg, val);
 
   // Just reading the register
   Memory::Write_U32(val, request.buffer_out);
@@ -377,7 +377,7 @@ IPCCommandResult SDIOSlot0::ReadHCRegister(const IOCtlRequest& request)
 
 IPCCommandResult SDIOSlot0::ResetCard(const IOCtlRequest& request)
 {
-  INFO_LOG(IOS_SD, "IOCTL_RESETCARD");
+  INFO_LOG_FMT(IOS_SD, "IOCTL_RESETCARD");
 
   // Returns 16bit RCA and 16bit 0s (meaning success)
   Memory::Write_U32(m_status, request.buffer_out);
@@ -387,21 +387,21 @@ IPCCommandResult SDIOSlot0::ResetCard(const IOCtlRequest& request)
 
 IPCCommandResult SDIOSlot0::SetClk(const IOCtlRequest& request)
 {
-  INFO_LOG(IOS_SD, "IOCTL_SETCLK");
+  INFO_LOG_FMT(IOS_SD, "IOCTL_SETCLK");
 
   // libogc only sets it to 1 and makes sure the return isn't negative...
   // one half of the sdclk divisor: a power of two or zero.
-  u32 clock = Memory::Read_U32(request.buffer_in);
+  const u32 clock = Memory::Read_U32(request.buffer_in);
   if (clock != 1)
-    INFO_LOG(IOS_SD, "Setting to %i, interesting", clock);
+    INFO_LOG_FMT(IOS_SD, "Setting to {}, interesting", clock);
 
   return GetDefaultReply(IPC_SUCCESS);
 }
 
 IPCCommandResult SDIOSlot0::SendCommand(const IOCtlRequest& request)
 {
-  INFO_LOG(IOS_SD, "IOCTL_SENDCMD %x IPC:%08x", Memory::Read_U32(request.buffer_in),
-           request.address);
+  INFO_LOG_FMT(IOS_SD, "IOCTL_SENDCMD {:x} IPC:{:08x}", Memory::Read_U32(request.buffer_in),
+               request.address);
 
   const s32 return_value = ExecuteCommand(request, request.buffer_in, request.buffer_in_size, 0, 0,
                                           request.buffer_out, request.buffer_out_size);
@@ -444,27 +444,27 @@ IPCCommandResult SDIOSlot0::GetStatus(const IOCtlRequest& request)
   const u32 status =
       SConfig::GetInstance().m_WiiSDCard ? (m_status | CARD_INSERTED) : CARD_NOT_EXIST;
 
-  INFO_LOG(IOS_SD, "IOCTL_GETSTATUS. Replying that %s card is %s%s",
-           (status & CARD_SDHC) ? "SDHC" : "SD",
-           (status & CARD_INSERTED) ? "inserted" : "not present",
-           (status & CARD_INITIALIZED) ? " and initialized" : "");
+  INFO_LOG_FMT(IOS_SD, "IOCTL_GETSTATUS. Replying that {} card is {}{}",
+               (status & CARD_SDHC) ? "SDHC" : "SD",
+               (status & CARD_INSERTED) ? "inserted" : "not present",
+               (status & CARD_INITIALIZED) ? " and initialized" : "");
 
   Memory::Write_U32(status, request.buffer_out);
   return GetDefaultReply(IPC_SUCCESS);
 }
 
 IPCCommandResult SDIOSlot0::GetOCRegister(const IOCtlRequest& request)
 {
-  u32 ocr = GetOCRegister();
-  INFO_LOG(IOS_SD, "IOCTL_GETOCR. Replying with ocr %x", ocr);
+  const u32 ocr = GetOCRegister();
+  INFO_LOG_FMT(IOS_SD, "IOCTL_GETOCR. Replying with ocr {:x}", ocr);
   Memory::Write_U32(ocr, request.buffer_out);
 
   return GetDefaultReply(IPC_SUCCESS);
 }
 
 IPCCommandResult SDIOSlot0::SendCommand(const IOCtlVRequest& request)
 {
-  DEBUG_LOG(IOS_SD, "IOCTLV_SENDCMD 0x%08x", Memory::Read_U32(request.in_vectors[0].address));
+  DEBUG_LOG_FMT(IOS_SD, "IOCTLV_SENDCMD {:#010x}", Memory::Read_U32(request.in_vectors[0].address));
   Memory::Memset(request.io_vectors[0].address, 0, request.io_vectors[0].size);
 
   const s32 return_value =
@@ -502,7 +502,7 @@ std::array<u32, 4> SDIOSlot0::GetCSDv1() const
     size >>= 1;
     if (++c_size_mult >= 8 + 2 + read_bl_len)
     {
-      ERROR_LOG(IOS_SD, "SD Card is too big!");
+      ERROR_LOG_FMT(IOS_SD, "SD Card is too big!");
       // Set max values
       size = 4096;
       c_size_mult = 7 + 2 + read_bl_len;
@@ -513,9 +513,9 @@ std::array<u32, 4> SDIOSlot0::GetCSDv1() const
   const u32 c_size(size);
 
   if (invalid_size)
-    WARN_LOG(IOS_SD, "SD Card size is invalid");
+    WARN_LOG_FMT(IOS_SD, "SD Card size is invalid");
   else
-    INFO_LOG(IOS_SD, "SD C_SIZE = %u, C_SIZE_MULT = %u", c_size, c_size_mult);
+    INFO_LOG_FMT(IOS_SD, "SD C_SIZE = {}, C_SIZE_MULT = {}", c_size, c_size_mult);
 
   // 0b00           CSD_STRUCTURE (SDv1)
   // 0b000000       reserved
@@ -574,7 +574,7 @@ std::array<u32, 4> SDIOSlot0::GetCSDv2() const
   const u64 size = m_card.GetSize();
 
   if (size % (512 * 1024) != 0)
-    WARN_LOG(IOS_SD, "SDHC Card size cannot be divided by 1024 * 512");
+    WARN_LOG_FMT(IOS_SD, "SDHC Card size cannot be divided by 1024 * 512");
 
   const u32 c_size(size / (512 * 1024) - 1);
 

diff --git a/Source/Core/Core/IOS/STM/STM.cpp b/Source/Core/Core/IOS/STM/STM.cpp
@@ -23,7 +23,7 @@ IPCCommandResult STMImmediate::IOCtl(const IOCtlRequest& request)
   {
   case IOCTL_STM_IDLE:
   case IOCTL_STM_SHUTDOWN:
-    NOTICE_LOG(IOS_STM, "IOCTL_STM_IDLE or IOCTL_STM_SHUTDOWN received, shutting down");
+    NOTICE_LOG_FMT(IOS_STM, "IOCTL_STM_IDLE or IOCTL_STM_SHUTDOWN received, shutting down");
     Core::QueueHostJob(&Core::Stop, false);
     break;
 
@@ -39,20 +39,20 @@ IPCCommandResult STMImmediate::IOCtl(const IOCtlRequest& request)
     break;
 
   case IOCTL_STM_HOTRESET:
-    INFO_LOG(IOS_STM, "%s - IOCtl:", GetDeviceName().c_str());
-    INFO_LOG(IOS_STM, "    IOCTL_STM_HOTRESET");
+    INFO_LOG_FMT(IOS_STM, "{} - IOCtl:", GetDeviceName());
+    INFO_LOG_FMT(IOS_STM, "    IOCTL_STM_HOTRESET");
     break;
 
   case IOCTL_STM_VIDIMMING:  // (Input: 20 bytes, Output: 20 bytes)
-    INFO_LOG(IOS_STM, "%s - IOCtl:", GetDeviceName().c_str());
-    INFO_LOG(IOS_STM, "    IOCTL_STM_VIDIMMING");
+    INFO_LOG_FMT(IOS_STM, "{} - IOCtl:", GetDeviceName());
+    INFO_LOG_FMT(IOS_STM, "    IOCTL_STM_VIDIMMING");
     // Memory::Write_U32(1, buffer_out);
     // return_value = 1;
     break;
 
   case IOCTL_STM_LEDMODE:  // (Input: 20 bytes, Output: 20 bytes)
-    INFO_LOG(IOS_STM, "%s - IOCtl:", GetDeviceName().c_str());
-    INFO_LOG(IOS_STM, "    IOCTL_STM_LEDMODE");
+    INFO_LOG_FMT(IOS_STM, "{} - IOCtl:", GetDeviceName());
+    INFO_LOG_FMT(IOS_STM, "    IOCTL_STM_LEDMODE");
     break;
 
   default:

diff --git a/Source/Core/Core/IOS/USB/Bluetooth/BTBase.cpp b/Source/Core/Core/IOS/USB/Bluetooth/BTBase.cpp
@@ -30,7 +30,7 @@ void BackUpBTInfoSection(const SysConf* sysconf)
 
   const std::vector<u8>& section = btdinf->bytes;
   if (!backup.WriteBytes(section.data(), section.size()))
-    ERROR_LOG(IOS_WIIMOTE, "Failed to back up BT.DINF section");
+    ERROR_LOG_FMT(IOS_WIIMOTE, "Failed to back up BT.DINF section");
 }
 
 void RestoreBTInfoSection(SysConf* sysconf)
@@ -43,7 +43,7 @@ void RestoreBTInfoSection(SysConf* sysconf)
     auto& section = sysconf->GetOrAddEntry("BT.DINF", SysConf::Entry::Type::BigArray)->bytes;
     if (!backup.ReadBytes(section.data(), section.size()))
     {
-      ERROR_LOG(IOS_WIIMOTE, "Failed to read backed up BT.DINF section");
+      ERROR_LOG_FMT(IOS_WIIMOTE, "Failed to read backed up BT.DINF section");
       return;
     }
   }

diff --git a/Source/Core/Core/IOS/USB/Bluetooth/BTEmu.cpp b/Source/Core/Core/IOS/USB/Bluetooth/BTEmu.cpp
diff --git a/Source/Core/Core/IOS/USB/Bluetooth/BTReal.cpp b/Source/Core/Core/IOS/USB/Bluetooth/BTReal.cpp
@@ -89,8 +89,8 @@ IPCCommandResult BluetoothReal::Open(const OpenRequest& request)
     auto config_descriptor = LibusbUtils::MakeConfigDescriptor(device);
     if (!config_descriptor)
     {
-      ERROR_LOG(IOS_WIIMOTE, "Failed to get config descriptor for device %04x:%04x",
-                device_descriptor.idVendor, device_descriptor.idProduct);
+      ERROR_LOG_FMT(IOS_WIIMOTE, "Failed to get config descriptor for device {:04x}:{:04x}",
+                    device_descriptor.idVendor, device_descriptor.idProduct);
       return true;
     }
 
@@ -105,9 +105,9 @@ IPCCommandResult BluetoothReal::Open(const OpenRequest& request)
                                          sizeof(product));
       libusb_get_string_descriptor_ascii(m_handle, device_descriptor.iSerialNumber, serial_number,
                                          sizeof(serial_number));
-      NOTICE_LOG(IOS_WIIMOTE, "Using device %04x:%04x (rev %x) for Bluetooth: %s %s %s",
-                 device_descriptor.idVendor, device_descriptor.idProduct,
-                 device_descriptor.bcdDevice, manufacturer, product, serial_number);
+      NOTICE_LOG_FMT(IOS_WIIMOTE, "Using device {:04x}:{:04x} (rev {:x}) for Bluetooth: {} {} {}",
+                     device_descriptor.idVendor, device_descriptor.idProduct,
+                     device_descriptor.bcdDevice, manufacturer, product, serial_number);
       m_is_wii_bt_module =
           device_descriptor.idVendor == 0x57e && device_descriptor.idProduct == 0x305;
       return false;
@@ -119,16 +119,17 @@ IPCCommandResult BluetoothReal::Open(const OpenRequest& request)
   {
     if (m_last_open_error.empty())
     {
-      CriticalAlertT(
+      CriticalAlertFmtT(
           "Could not find any usable Bluetooth USB adapter for Bluetooth Passthrough.\n\n"
           "The emulated console will now stop.");
     }
     else
     {
-      CriticalAlertT("Could not find any usable Bluetooth USB adapter for Bluetooth Passthrough.\n"
-                     "The following error occurred when Dolphin tried to use an adapter:\n%s\n\n"
-                     "The emulated console will now stop.",
-                     m_last_open_error.c_str());
+      CriticalAlertFmtT(
+          "Could not find any usable Bluetooth USB adapter for Bluetooth Passthrough.\n"
+          "The following error occurred when Dolphin tried to use an adapter:\n{0}\n\n"
+          "The emulated console will now stop.",
+          m_last_open_error);
     }
     Core::QueueHostJob(Core::Stop);
     return GetDefaultReply(IPC_ENOENT);
@@ -368,7 +369,7 @@ void BluetoothReal::SendHCIResetCommand()
   const u16 payload[] = {HCI_CMD_RESET};
   memcpy(packet, payload, sizeof(payload));
   libusb_control_transfer(m_handle, REQUEST_TYPE, 0, 0, 0, packet, sizeof(packet), TIMEOUT);
-  INFO_LOG(IOS_WIIMOTE, "Sent a reset command to adapter");
+  INFO_LOG_FMT(IOS_WIIMOTE, "Sent a reset command to adapter");
 }
 
 void BluetoothReal::SendHCIDeleteLinkKeyCommand()
@@ -481,17 +482,17 @@ void BluetoothReal::FakeSyncButtonEvent(USB::V0IntrMessage& ctrl, const u8* payl
 // This causes the emulated software to perform a BT inquiry and connect to found Wiimotes.
 void BluetoothReal::FakeSyncButtonPressedEvent(USB::V0IntrMessage& ctrl)
 {
-  NOTICE_LOG(IOS_WIIMOTE, "Faking 'sync button pressed' (0x08) event packet");
-  const u8 payload[1] = {0x08};
+  NOTICE_LOG_FMT(IOS_WIIMOTE, "Faking 'sync button pressed' (0x08) event packet");
+  constexpr u8 payload[1] = {0x08};
   FakeSyncButtonEvent(ctrl, payload, sizeof(payload));
   m_sync_button_state = SyncButtonState::Ignored;
 }
 
 // When the red sync button is held for 10 seconds, a HCI event with payload 09 is sent.
 void BluetoothReal::FakeSyncButtonHeldEvent(USB::V0IntrMessage& ctrl)
 {
-  NOTICE_LOG(IOS_WIIMOTE, "Faking 'sync button held' (0x09) event packet");
-  const u8 payload[1] = {0x09};
+  NOTICE_LOG_FMT(IOS_WIIMOTE, "Faking 'sync button held' (0x09) event packet");
+  constexpr u8 payload[1] = {0x09};
   FakeSyncButtonEvent(ctrl, payload, sizeof(payload));
   m_sync_button_state = SyncButtonState::Ignored;
 }
@@ -511,8 +512,9 @@ void BluetoothReal::LoadLinkKeys()
     std::optional<bdaddr_t> address = Common::StringToMacAddress(address_string);
     if (!address)
     {
-      ERROR_LOG(IOS_WIIMOTE, "Malformed MAC address (%s). Skipping loading of current link key.",
-                address_string.c_str());
+      ERROR_LOG_FMT(IOS_WIIMOTE,
+                    "Malformed MAC address ({}). Skipping loading of current link key.",
+                    address_string);
       continue;
     }
 
@@ -598,7 +600,7 @@ void BluetoothReal::HandleCtrlTransfer(libusb_transfer* tr)
 
   if (tr->status != LIBUSB_TRANSFER_COMPLETED && tr->status != LIBUSB_TRANSFER_NO_DEVICE)
   {
-    ERROR_LOG(IOS_WIIMOTE, "libusb command transfer failed, status: 0x%02x", tr->status);
+    ERROR_LOG_FMT(IOS_WIIMOTE, "libusb command transfer failed, status: {:#04x}", tr->status);
     if (!m_showed_failed_transfer.IsSet())
     {
       Core::DisplayMessage("Failed to send a command to the Bluetooth adapter.", 10000);
@@ -625,7 +627,7 @@ void BluetoothReal::HandleBulkOrIntrTransfer(libusb_transfer* tr)
   if (tr->status != LIBUSB_TRANSFER_COMPLETED && tr->status != LIBUSB_TRANSFER_TIMED_OUT &&
       tr->status != LIBUSB_TRANSFER_NO_DEVICE)
   {
-    ERROR_LOG(IOS_WIIMOTE, "libusb transfer failed, status: 0x%02x", tr->status);
+    ERROR_LOG_FMT(IOS_WIIMOTE, "libusb transfer failed, status: {:#04x}", tr->status);
     if (!m_showed_failed_transfer.IsSet())
     {
       Core::DisplayMessage("Failed to transfer to or from to the Bluetooth adapter.", 10000);

diff --git a/Source/Core/Core/IOS/USB/Bluetooth/BTStub.cpp b/Source/Core/Core/IOS/USB/Bluetooth/BTStub.cpp
@@ -12,8 +12,8 @@ namespace IOS::HLE::Device
 {
 IPCCommandResult BluetoothStub::Open(const OpenRequest& request)
 {
-  PanicAlertT("Bluetooth passthrough mode is enabled, but Dolphin was built without libusb."
-              " Passthrough mode cannot be used.");
+  PanicAlertFmtT("Bluetooth passthrough mode is enabled, but Dolphin was built without libusb."
+                 " Passthrough mode cannot be used.");
   return GetDefaultReply(IPC_ENOENT);
 }
 

diff --git a/Source/Core/Core/IOS/USB/Bluetooth/WiimoteDevice.cpp b/Source/Core/Core/IOS/USB/Bluetooth/WiimoteDevice.cpp
@@ -60,7 +60,7 @@ WiimoteDevice::WiimoteDevice(Device::BluetoothEmu* host, int number, bdaddr_t bd
       m_name(number == WIIMOTE_BALANCE_BOARD ? "Nintendo RVL-WBC-01" : "Nintendo RVL-CNT-01")
 
 {
-  INFO_LOG(IOS_WIIMOTE, "Wiimote: #%i Constructed", number);
+  INFO_LOG_FMT(IOS_WIIMOTE, "Wiimote: #{} Constructed", number);
 
   m_link_key.fill(0xa0 + number);
   m_class = {0x00, 0x04, 0x48};
@@ -335,7 +335,7 @@ void WiimoteDevice::Update()
   {
     if (LinkChannel(L2CAP_PSM_HID_CNTL) && LinkChannel(L2CAP_PSM_HID_INTR))
     {
-      DEBUG_LOG(IOS_WIIMOTE, "HID linking is complete.");
+      DEBUG_LOG_FMT(IOS_WIIMOTE, "HID linking is complete.");
       m_hid_state = HIDState::Inactive;
     }
   }
@@ -368,12 +368,12 @@ void WiimoteDevice::ExecuteL2capCmd(u8* ptr, u32 size)
   l2cap_hdr_t* header = (l2cap_hdr_t*)ptr;
   u8* data = ptr + sizeof(l2cap_hdr_t);
   const u32 data_size = size - sizeof(l2cap_hdr_t);
-  DEBUG_LOG(IOS_WIIMOTE, "  CID 0x%04x, Len 0x%x, DataSize 0x%x", header->dcid, header->length,
-            data_size);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "  CID {:#06x}, Len {:#x}, DataSize {:#x}", header->dcid,
+                header->length, data_size);
 
   if (header->length != data_size)
   {
-    INFO_LOG(IOS_WIIMOTE, "Faulty packet. It is dropped.");
+    INFO_LOG_FMT(IOS_WIIMOTE, "Faulty packet. It is dropped.");
     return;
   }
 
@@ -386,7 +386,7 @@ void WiimoteDevice::ExecuteL2capCmd(u8* ptr, u32 size)
   const auto itr = m_channels.find(header->dcid);
   if (itr == m_channels.end())
   {
-    ERROR_LOG(IOS_WIIMOTE, "L2CAP: SendACLPacket to unknown channel %i", header->dcid);
+    ERROR_LOG_FMT(IOS_WIIMOTE, "L2CAP: SendACLPacket to unknown channel {}", header->dcid);
     return;
   }
 
@@ -423,7 +423,7 @@ void WiimoteDevice::ExecuteL2capCmd(u8* ptr, u32 size)
     }
     else
     {
-      ERROR_LOG(IOS_WIIMOTE, "Unknown HID-type (0x%x) on L2CAP_PSM_HID_CNTL", hid_type);
+      ERROR_LOG_FMT(IOS_WIIMOTE, "Unknown HID-type ({:#x}) on L2CAP_PSM_HID_CNTL", hid_type);
     }
   }
   break;
@@ -434,12 +434,12 @@ void WiimoteDevice::ExecuteL2capCmd(u8* ptr, u32 size)
     if (hid_type == ((WiimoteCommon::HID_TYPE_DATA << 4) | WiimoteCommon::HID_PARAM_OUTPUT))
       m_hid_source->InterruptDataOutput(data + sizeof(hid_type), data_size - sizeof(hid_type));
     else
-      ERROR_LOG(IOS_WIIMOTE, "Unknown HID-type (0x%x) on L2CAP_PSM_HID_INTR", hid_type);
+      ERROR_LOG_FMT(IOS_WIIMOTE, "Unknown HID-type ({:#x}) on L2CAP_PSM_HID_INTR", hid_type);
   }
   break;
 
   default:
-    ERROR_LOG(IOS_WIIMOTE, "Channel 0x%x has unknown PSM %x", header->dcid, channel.psm);
+    ERROR_LOG_FMT(IOS_WIIMOTE, "Channel {:#x} has unknown PSM {:x}", header->dcid, channel.psm);
     break;
   }
 }
@@ -455,8 +455,8 @@ void WiimoteDevice::SignalChannel(u8* data, u32 size)
     switch (cmd_hdr->code)
     {
     case L2CAP_COMMAND_REJ:
-      ERROR_LOG(IOS_WIIMOTE, "SignalChannel - L2CAP_COMMAND_REJ (something went wrong)."
-                             "Try to replace your SYSCONF file with a new copy.");
+      ERROR_LOG_FMT(IOS_WIIMOTE, "SignalChannel - L2CAP_COMMAND_REJ (something went wrong)."
+                                 "Try to replace your SYSCONF file with a new copy.");
       break;
 
     case L2CAP_CONNECT_REQ:
@@ -480,7 +480,7 @@ void WiimoteDevice::SignalChannel(u8* data, u32 size)
       break;
 
     default:
-      ERROR_LOG(IOS_WIIMOTE, "  Unknown Command-Code (0x%02x)", cmd_hdr->code);
+      ERROR_LOG_FMT(IOS_WIIMOTE, "  Unknown Command-Code ({:#04x})", cmd_hdr->code);
       return;
     }
 
@@ -492,19 +492,19 @@ void WiimoteDevice::ReceiveConnectionReq(u8 ident, u8* data, u32 size)
 {
   l2cap_con_req_cp* command_connection_req = (l2cap_con_req_cp*)data;
 
-  DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] ReceiveConnectionRequest");
-  DEBUG_LOG(IOS_WIIMOTE, "    Ident: 0x%02x", ident);
-  DEBUG_LOG(IOS_WIIMOTE, "    PSM: 0x%04x", command_connection_req->psm);
-  DEBUG_LOG(IOS_WIIMOTE, "    SCID: 0x%04x", command_connection_req->scid);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "[L2CAP] ReceiveConnectionRequest");
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Ident: {:#04x}", ident);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    PSM: {:#06x}", command_connection_req->psm);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    SCID: {:#06x}", command_connection_req->scid);
 
   l2cap_con_rsp_cp rsp = {};
   rsp.scid = command_connection_req->scid;
   rsp.status = L2CAP_NO_INFO;
 
   if (FindChannelWithPSM(command_connection_req->psm) != nullptr)
   {
-    ERROR_LOG(IOS_WIIMOTE, "Multiple channels with same PSM (%d) are not allowed.",
-              command_connection_req->psm);
+    ERROR_LOG_FMT(IOS_WIIMOTE, "Multiple channels with same PSM ({}) are not allowed.",
+                  command_connection_req->psm);
 
     // A real wii remote refuses multiple connections with the same PSM.
     rsp.result = L2CAP_NO_RESOURCES;
@@ -522,14 +522,14 @@ void WiimoteDevice::ReceiveConnectionReq(u8 ident, u8* data, u32 size)
     if (channel.psm != L2CAP_PSM_SDP && channel.psm != L2CAP_PSM_HID_CNTL &&
         channel.psm != L2CAP_PSM_HID_INTR)
     {
-      WARN_LOG(IOS_WIIMOTE, "L2CAP connection with unknown psm (0x%x)", channel.psm);
+      WARN_LOG_FMT(IOS_WIIMOTE, "L2CAP connection with unknown psm ({:#x})", channel.psm);
     }
 
     rsp.result = L2CAP_SUCCESS;
     rsp.dcid = local_cid;
   }
 
-  DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] SendConnectionResponse");
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "[L2CAP] SendConnectionResponse");
   SendCommandToACL(ident, L2CAP_CONNECT_RSP, sizeof(l2cap_con_rsp_cp), (u8*)&rsp);
 }
 
@@ -539,11 +539,11 @@ void WiimoteDevice::ReceiveConnectionResponse(u8 ident, u8* data, u32 size)
 
   DEBUG_ASSERT(size == sizeof(l2cap_con_rsp_cp));
 
-  DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] ReceiveConnectionResponse");
-  DEBUG_LOG(IOS_WIIMOTE, "    DCID: 0x%04x", rsp->dcid);
-  DEBUG_LOG(IOS_WIIMOTE, "    SCID: 0x%04x", rsp->scid);
-  DEBUG_LOG(IOS_WIIMOTE, "    Result: 0x%04x", rsp->result);
-  DEBUG_LOG(IOS_WIIMOTE, "    Status: 0x%04x", rsp->status);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "[L2CAP] ReceiveConnectionResponse");
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    DCID: {:#06x}", rsp->dcid);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    SCID: {:#06x}", rsp->scid);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Result: {:#06x}", rsp->result);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Status: {:#06x}", rsp->status);
 
   DEBUG_ASSERT(rsp->result == L2CAP_SUCCESS);
   DEBUG_ASSERT(rsp->status == L2CAP_NO_INFO);
@@ -564,10 +564,10 @@ void WiimoteDevice::ReceiveConfigurationReq(u8 ident, u8* data, u32 size)
 
   SChannel& channel = m_channels[command_config_req->dcid];
 
-  DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] ReceiveConfigurationRequest");
-  DEBUG_LOG(IOS_WIIMOTE, "    Ident: 0x%02x", ident);
-  DEBUG_LOG(IOS_WIIMOTE, "    DCID: 0x%04x", command_config_req->dcid);
-  DEBUG_LOG(IOS_WIIMOTE, "    Flags: 0x%04x", command_config_req->flags);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "[L2CAP] ReceiveConfigurationRequest");
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Ident: {:#04x}", ident);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    DCID: {:#06x}", command_config_req->dcid);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Flags: {:#06x}", command_config_req->flags);
 
   offset += sizeof(l2cap_cfg_req_cp);
 
@@ -597,7 +597,7 @@ void WiimoteDevice::ReceiveConfigurationReq(u8 ident, u8* data, u32 size)
       DEBUG_ASSERT(options->length == L2CAP_OPT_MTU_SIZE);
       l2cap_cfg_opt_val_t* mtu = (l2cap_cfg_opt_val_t*)&data[offset];
       remote_mtu = mtu->mtu;
-      DEBUG_LOG(IOS_WIIMOTE, "    MTU: 0x%04x", mtu->mtu);
+      DEBUG_LOG_FMT(IOS_WIIMOTE, "    MTU: {:#06x}", mtu->mtu);
     }
     break;
 
@@ -606,12 +606,12 @@ void WiimoteDevice::ReceiveConfigurationReq(u8 ident, u8* data, u32 size)
     {
       DEBUG_ASSERT(options->length == L2CAP_OPT_FLUSH_TIMO_SIZE);
       l2cap_cfg_opt_val_t* flush_time_out = (l2cap_cfg_opt_val_t*)&data[offset];
-      DEBUG_LOG(IOS_WIIMOTE, "    FlushTimeOut: 0x%04x", flush_time_out->flush_timo);
+      DEBUG_LOG_FMT(IOS_WIIMOTE, "    FlushTimeOut: {:#06x}", flush_time_out->flush_timo);
     }
     break;
 
     default:
-      DEBUG_ASSERT_MSG(IOS_WIIMOTE, 0, "Unknown Option: 0x%02x", options->type);
+      DEBUG_ASSERT_MSG(IOS_WIIMOTE, 0, "Unknown Option: {:#04x}", options->type);
       break;
     }
 
@@ -622,7 +622,7 @@ void WiimoteDevice::ReceiveConfigurationReq(u8 ident, u8* data, u32 size)
     resp_len += option_size;
   }
 
-  DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] SendConfigurationResponse");
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "[L2CAP] SendConfigurationResponse");
   SendCommandToACL(ident, L2CAP_CONFIG_RSP, resp_len, temp_buffer);
 
   channel.remote_mtu = remote_mtu;
@@ -632,10 +632,10 @@ void WiimoteDevice::ReceiveConfigurationResponse(u8 ident, u8* data, u32 size)
 {
   l2cap_cfg_rsp_cp* rsp = (l2cap_cfg_rsp_cp*)data;
 
-  DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] ReceiveConfigurationResponse");
-  DEBUG_LOG(IOS_WIIMOTE, "    SCID: 0x%04x", rsp->scid);
-  DEBUG_LOG(IOS_WIIMOTE, "    Flags: 0x%04x", rsp->flags);
-  DEBUG_LOG(IOS_WIIMOTE, "    Result: 0x%04x", rsp->result);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "[L2CAP] ReceiveConfigurationResponse");
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    SCID: {:#06x}", rsp->scid);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Flags: {:#06x}", rsp->flags);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Result: {:#06x}", rsp->result);
 
   DEBUG_ASSERT(rsp->result == L2CAP_SUCCESS);
 
@@ -646,10 +646,10 @@ void WiimoteDevice::ReceiveDisconnectionReq(u8 ident, u8* data, u32 size)
 {
   l2cap_discon_req_cp* command_disconnection_req = (l2cap_discon_req_cp*)data;
 
-  DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] ReceiveDisconnectionReq");
-  DEBUG_LOG(IOS_WIIMOTE, "    Ident: 0x%02x", ident);
-  DEBUG_LOG(IOS_WIIMOTE, "    DCID: 0x%04x", command_disconnection_req->dcid);
-  DEBUG_LOG(IOS_WIIMOTE, "    SCID: 0x%04x", command_disconnection_req->scid);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "[L2CAP] ReceiveDisconnectionReq");
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Ident: {:#04x}", ident);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    DCID: {:#06x}", command_disconnection_req->dcid);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    SCID: {:#06x}", command_disconnection_req->scid);
 
   DEBUG_ASSERT(DoesChannelExist(command_disconnection_req->dcid));
 
@@ -659,7 +659,7 @@ void WiimoteDevice::ReceiveDisconnectionReq(u8 ident, u8* data, u32 size)
   rsp.dcid = command_disconnection_req->dcid;
   rsp.scid = command_disconnection_req->scid;
 
-  DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] SendDisconnectionResponse");
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "[L2CAP] SendDisconnectionResponse");
   SendCommandToACL(ident, L2CAP_DISCONNECT_RSP, sizeof(l2cap_discon_req_cp), (u8*)&rsp);
 }
 
@@ -677,9 +677,9 @@ void WiimoteDevice::SendConnectionRequest(u16 psm)
   cr.psm = psm;
   cr.scid = local_cid;
 
-  DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] SendConnectionRequest");
-  DEBUG_LOG(IOS_WIIMOTE, "    Psm: 0x%04x", cr.psm);
-  DEBUG_LOG(IOS_WIIMOTE, "    Scid: 0x%04x", cr.scid);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "[L2CAP] SendConnectionRequest");
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Psm: {:#06x}", cr.psm);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Scid: {:#06x}", cr.scid);
 
   SendCommandToACL(L2CAP_CONNECT_REQ, L2CAP_CONNECT_REQ, sizeof(l2cap_con_req_cp), (u8*)&cr);
 }
@@ -694,9 +694,9 @@ void WiimoteDevice::SendConfigurationRequest(u16 cid, u16 mtu, u16 flush_time_ou
   cr->flags = 0;
   offset += sizeof(l2cap_cfg_req_cp);
 
-  DEBUG_LOG(IOS_WIIMOTE, "[L2CAP] SendConfigurationRequest");
-  DEBUG_LOG(IOS_WIIMOTE, "    Dcid: 0x%04x", cr->dcid);
-  DEBUG_LOG(IOS_WIIMOTE, "    Flags: 0x%04x", cr->flags);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "[L2CAP] SendConfigurationRequest");
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Dcid: {:#06x}", cr->dcid);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Flags: {:#06x}", cr->flags);
 
   l2cap_cfg_opt_t* options;
 
@@ -708,7 +708,7 @@ void WiimoteDevice::SendConfigurationRequest(u16 cid, u16 mtu, u16 flush_time_ou
     options->length = L2CAP_OPT_MTU_SIZE;
     *(u16*)&buffer[offset] = mtu;
     offset += L2CAP_OPT_MTU_SIZE;
-    DEBUG_LOG(IOS_WIIMOTE, "    MTU: 0x%04x", mtu);
+    DEBUG_LOG_FMT(IOS_WIIMOTE, "    MTU: {:#06x}", mtu);
   }
 
   if (flush_time_out != L2CAP_FLUSH_TIMO_DEFAULT)
@@ -719,7 +719,7 @@ void WiimoteDevice::SendConfigurationRequest(u16 cid, u16 mtu, u16 flush_time_ou
     options->length = L2CAP_OPT_FLUSH_TIMO_SIZE;
     *(u16*)&buffer[offset] = flush_time_out;
     offset += L2CAP_OPT_FLUSH_TIMO_SIZE;
-    DEBUG_LOG(IOS_WIIMOTE, "    FlushTimeOut: 0x%04x", flush_time_out);
+    DEBUG_LOG_FMT(IOS_WIIMOTE, "    FlushTimeOut: {:#06x}", flush_time_out);
   }
 
   SendCommandToACL(L2CAP_CONFIG_REQ, L2CAP_CONFIG_REQ, offset, buffer);
@@ -788,8 +788,8 @@ static u32 ParseCont(u8* cont)
   {
     return 0x00;
   }
-  ERROR_LOG(IOS_WIIMOTE, "ParseCont: wrong cont: %i", type_id);
-  PanicAlert("ParseCont: wrong cont: %i", type_id);
+  ERROR_LOG_FMT(IOS_WIIMOTE, "ParseCont: wrong cont: {}", type_id);
+  PanicAlertFmt("ParseCont: wrong cont: {}", type_id);
   return 0;
 }
 
@@ -823,8 +823,8 @@ static int ParseAttribList(u8* attrib_id_list, u16& start_id, u16& end_id)
     start_id = attrib_list.Read16(attrib_offset);
     attrib_offset += 2;
     end_id = start_id;
-    WARN_LOG(IOS_WIIMOTE, "Read just a single attrib - not tested");
-    PanicAlert("Read just a single attrib - not tested");
+    WARN_LOG_FMT(IOS_WIIMOTE, "Read just a single attrib - not tested");
+    PanicAlertFmt("Read just a single attrib - not tested");
   }
 
   return attrib_offset;
@@ -837,8 +837,8 @@ void WiimoteDevice::SDPSendServiceAttributeResponse(u16 cid, u16 transaction_id,
 {
   if (service_handle != 0x10000)
   {
-    ERROR_LOG(IOS_WIIMOTE, "Unknown service handle %x", service_handle);
-    PanicAlert("Unknown service handle %x", service_handle);
+    ERROR_LOG_FMT(IOS_WIIMOTE, "Unknown service handle {:x}", service_handle);
+    PanicAlertFmt("Unknown service handle {:x}", service_handle);
   }
 
   const u32 cont_state = ParseCont(continuation_state);
@@ -876,7 +876,7 @@ void WiimoteDevice::HandleSDP(u16 cid, u8* data, u32 size)
   // SDP_ServiceSearchRequest
   case 0x02:
   {
-    WARN_LOG(IOS_WIIMOTE, "!!! SDP_ServiceSearchRequest !!!");
+    WARN_LOG_FMT(IOS_WIIMOTE, "!!! SDP_ServiceSearchRequest !!!");
 
     DEBUG_ASSERT(size == 13);
 
@@ -892,7 +892,7 @@ void WiimoteDevice::HandleSDP(u16 cid, u8* data, u32 size)
   // SDP_ServiceAttributeRequest
   case 0x04:
   {
-    WARN_LOG(IOS_WIIMOTE, "!!! SDP_ServiceAttributeRequest !!!");
+    WARN_LOG_FMT(IOS_WIIMOTE, "!!! SDP_ServiceAttributeRequest !!!");
 
     u16 start_attr_id, end_attr_id;
     u32 offset = 1;
@@ -914,8 +914,8 @@ void WiimoteDevice::HandleSDP(u16 cid, u8* data, u32 size)
   break;
 
   default:
-    ERROR_LOG(IOS_WIIMOTE, "Unknown SDP command %x", data[0]);
-    PanicAlert("WIIMOTE: Unknown SDP command %x", data[0]);
+    ERROR_LOG_FMT(IOS_WIIMOTE, "Unknown SDP command {:x}", data[0]);
+    PanicAlertFmt("WIIMOTE: Unknown SDP command {:x}", data[0]);
     break;
   }
 }
@@ -938,9 +938,9 @@ void WiimoteDevice::SendCommandToACL(u8 ident, u8 code, u8 command_length, u8* c
 
   memcpy(&data_frame[offset], command_data, command_length);
 
-  DEBUG_LOG(IOS_WIIMOTE, "Send ACL Command to CPU");
-  DEBUG_LOG(IOS_WIIMOTE, "    Ident: 0x%02x", ident);
-  DEBUG_LOG(IOS_WIIMOTE, "    Code: 0x%02x", code);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "Send ACL Command to CPU");
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Ident: {:#04x}", ident);
+  DEBUG_LOG_FMT(IOS_WIIMOTE, "    Code: {:#04x}", code);
 
   m_host->SendACLPacket(GetBD(), data_frame, header->length + sizeof(l2cap_hdr_t));
 }
@@ -951,7 +951,7 @@ void WiimoteDevice::InterruptDataInputCallback(u8 hid_type, const u8* data, u32
 
   if (!channel)
   {
-    WARN_LOG(IOS_WIIMOTE, "Data callback with invalid L2CAP_PSM_HID_INTR channel.");
+    WARN_LOG_FMT(IOS_WIIMOTE, "Data callback with invalid L2CAP_PSM_HID_INTR channel.");
     return;
   }
 

diff --git a/Source/Core/Core/IOS/USB/Host.cpp b/Source/Core/Core/IOS/USB/Host.cpp
@@ -164,9 +164,9 @@ void USBHost::DispatchHooks(const DeviceChangeHooks& hooks)
 {
   for (const auto& hook : hooks)
   {
-    INFO_LOG(IOS_USB, "%s - %s device: %04x:%04x", GetDeviceName().c_str(),
-             hook.second == ChangeEvent::Inserted ? "New" : "Removed", hook.first->GetVid(),
-             hook.first->GetPid());
+    INFO_LOG_FMT(IOS_USB, "{} - {} device: {:04x}:{:04x}", GetDeviceName(),
+                 hook.second == ChangeEvent::Inserted ? "New" : "Removed", hook.first->GetVid(),
+                 hook.first->GetPid());
     OnDeviceChange(hook.second, hook.first);
   }
   if (!hooks.empty())
@@ -223,8 +223,8 @@ IPCCommandResult USBHost::HandleTransfer(std::shared_ptr<USB::Device> device, u3
   if (ret == IPC_SUCCESS)
     return GetNoReply();
 
-  ERROR_LOG(IOS_USB, "[%04x:%04x] Failed to submit transfer (request %u): %s", device->GetVid(),
-            device->GetPid(), request, device->GetErrorName(ret).c_str());
+  ERROR_LOG_FMT(IOS_USB, "[{:04x}:{:04x}] Failed to submit transfer (request {}): {}",
+                device->GetVid(), device->GetPid(), request, device->GetErrorName(ret));
   return GetDefaultReply(ret <= 0 ? ret : IPC_EINVAL);
 }
 }  // namespace IOS::HLE::Device
diff --git a/Source/Core/Core/IOS/USB/LibusbDevice.cpp b/Source/Core/Core/IOS/USB/LibusbDevice.cpp
@@ -67,7 +67,7 @@ std::vector<ConfigDescriptor> LibusbDevice::GetConfigurations() const
   {
     if (!config_descriptor)
     {
-      ERROR_LOG(IOS_USB, "Ignoring invalid config descriptor for %04x:%04x", m_vid, m_pid);
+      ERROR_LOG_FMT(IOS_USB, "Ignoring invalid config descriptor for {:04x}:{:04x}", m_vid, m_pid);
       continue;
     }
     ConfigDescriptor descriptor;
@@ -82,7 +82,7 @@ std::vector<InterfaceDescriptor> LibusbDevice::GetInterfaces(const u8 config) co
   std::vector<InterfaceDescriptor> descriptors;
   if (config >= m_config_descriptors.size() || !m_config_descriptors[config])
   {
-    ERROR_LOG(IOS_USB, "Invalid config descriptor %u for %04x:%04x", config, m_vid, m_pid);
+    ERROR_LOG_FMT(IOS_USB, "Invalid config descriptor {} for {:04x}:{:04x}", config, m_vid, m_pid);
     return descriptors;
   }
   for (u8 i = 0; i < m_config_descriptors[config]->bNumInterfaces; ++i)
@@ -104,7 +104,7 @@ LibusbDevice::GetEndpoints(const u8 config, const u8 interface_number, const u8
   std::vector<EndpointDescriptor> descriptors;
   if (config >= m_config_descriptors.size() || !m_config_descriptors[config])
   {
-    ERROR_LOG(IOS_USB, "Invalid config descriptor %u for %04x:%04x", config, m_vid, m_pid);
+    ERROR_LOG_FMT(IOS_USB, "Invalid config descriptor {} for {:04x}:{:04x}", config, m_vid, m_pid);
     return descriptors;
   }
   ASSERT(interface_number < m_config_descriptors[config]->bNumInterfaces);
@@ -132,11 +132,12 @@ bool LibusbDevice::Attach()
 
   if (!m_handle)
   {
-    NOTICE_LOG(IOS_USB, "[%04x:%04x] Opening device", m_vid, m_pid);
+    NOTICE_LOG_FMT(IOS_USB, "[{:04x}:{:04x}] Opening device", m_vid, m_pid);
     const int ret = libusb_open(m_device, &m_handle);
     if (ret != 0)
     {
-      ERROR_LOG(IOS_USB, "[%04x:%04x] Failed to open: %s", m_vid, m_pid, libusb_error_name(ret));
+      ERROR_LOG_FMT(IOS_USB, "[{:04x}:{:04x}] Failed to open: {}", m_vid, m_pid,
+                    libusb_error_name(ret));
       m_handle = nullptr;
       return false;
     }
@@ -160,8 +161,8 @@ bool LibusbDevice::AttachAndChangeInterface(const u8 interface)
 
 int LibusbDevice::CancelTransfer(const u8 endpoint)
 {
-  INFO_LOG(IOS_USB, "[%04x:%04x %d] Cancelling transfers (endpoint 0x%x)", m_vid, m_pid,
-           m_active_interface, endpoint);
+  INFO_LOG_FMT(IOS_USB, "[{:04x}:{:04x} {}] Cancelling transfers (endpoint {:#x})", m_vid, m_pid,
+               m_active_interface, endpoint);
   const auto iterator = m_transfer_endpoints.find(endpoint);
   if (iterator == m_transfer_endpoints.cend())
     return IPC_ENOENT;
@@ -171,8 +172,8 @@ int LibusbDevice::CancelTransfer(const u8 endpoint)
 
 int LibusbDevice::ChangeInterface(const u8 interface)
 {
-  INFO_LOG(IOS_USB, "[%04x:%04x %d] Changing interface to %d", m_vid, m_pid, m_active_interface,
-           interface);
+  INFO_LOG_FMT(IOS_USB, "[{:04x}:{:04x} {}] Changing interface to {}", m_vid, m_pid,
+               m_active_interface, interface);
   m_active_interface = interface;
   return 0;
 }
@@ -182,8 +183,8 @@ int LibusbDevice::SetAltSetting(const u8 alt_setting)
   if (!m_device_attached)
     return LIBUSB_ERROR_NOT_FOUND;
 
-  INFO_LOG(IOS_USB, "[%04x:%04x %d] Setting alt setting %d", m_vid, m_pid, m_active_interface,
-           alt_setting);
+  INFO_LOG_FMT(IOS_USB, "[{:04x}:{:04x} {}] Setting alt setting {}", m_vid, m_pid,
+               m_active_interface, alt_setting);
   return libusb_set_interface_alt_setting(m_handle, m_active_interface, alt_setting);
 }
 
@@ -192,26 +193,26 @@ int LibusbDevice::SubmitTransfer(std::unique_ptr<CtrlMessage> cmd)
   if (!m_device_attached)
     return LIBUSB_ERROR_NOT_FOUND;
 
-  DEBUG_LOG(IOS_USB,
-            "[%04x:%04x %d] Control: bRequestType=%02x bRequest=%02x wValue=%04x"
-            " wIndex=%04x wLength=%04x",
-            m_vid, m_pid, m_active_interface, cmd->request_type, cmd->request, cmd->value,
-            cmd->index, cmd->length);
+  DEBUG_LOG_FMT(IOS_USB,
+                "[{:04x}:{:04x} {}] Control: bRequestType={:02x} bRequest={:02x} wValue={:04x}"
+                " wIndex={:04x} wLength={:04x}",
+                m_vid, m_pid, m_active_interface, cmd->request_type, cmd->request, cmd->value,
+                cmd->index, cmd->length);
 
   switch ((cmd->request_type << 8) | cmd->request)
   {
   // The following requests have to go through libusb and cannot be directly sent to the device.
   case USBHDR(DIR_HOST2DEVICE, TYPE_STANDARD, REC_INTERFACE, REQUEST_SET_INTERFACE):
   {
-    INFO_LOG(IOS_USB, "[%04x:%04x %d] REQUEST_SET_INTERFACE index=%04x value=%04x", m_vid, m_pid,
-             m_active_interface, cmd->index, cmd->value);
+    INFO_LOG_FMT(IOS_USB, "[{:04x}:{:04x} {}] REQUEST_SET_INTERFACE index={:04x} value={:04x}",
+                 m_vid, m_pid, m_active_interface, cmd->index, cmd->value);
     if (static_cast<u8>(cmd->index) != m_active_interface)
     {
       const int ret = ChangeInterface(static_cast<u8>(cmd->index));
       if (ret < 0)
       {
-        ERROR_LOG(IOS_USB, "[%04x:%04x %d] Failed to change interface to %d: %s", m_vid, m_pid,
-                  m_active_interface, cmd->index, libusb_error_name(ret));
+        ERROR_LOG_FMT(IOS_USB, "[{:04x}:{:04x} {}] Failed to change interface to {}: {}", m_vid,
+                      m_pid, m_active_interface, cmd->index, libusb_error_name(ret));
         return ret;
       }
     }
@@ -222,8 +223,8 @@ int LibusbDevice::SubmitTransfer(std::unique_ptr<CtrlMessage> cmd)
   }
   case USBHDR(DIR_HOST2DEVICE, TYPE_STANDARD, REC_DEVICE, REQUEST_SET_CONFIGURATION):
   {
-    INFO_LOG(IOS_USB, "[%04x:%04x %d] REQUEST_SET_CONFIGURATION index=%04x value=%04x", m_vid,
-             m_pid, m_active_interface, cmd->index, cmd->value);
+    INFO_LOG_FMT(IOS_USB, "[{:04x}:{:04x} {}] REQUEST_SET_CONFIGURATION index={:04x} value={:04x}",
+                 m_vid, m_pid, m_active_interface, cmd->index, cmd->value);
     ReleaseAllInterfacesForCurrentConfig();
     const int ret = libusb_set_configuration(m_handle, cmd->value);
     if (ret == 0)
@@ -252,8 +253,8 @@ int LibusbDevice::SubmitTransfer(std::unique_ptr<BulkMessage> cmd)
   if (!m_device_attached)
     return LIBUSB_ERROR_NOT_FOUND;
 
-  DEBUG_LOG(IOS_USB, "[%04x:%04x %d] Bulk: length=%04x endpoint=%02x", m_vid, m_pid,
-            m_active_interface, cmd->length, cmd->endpoint);
+  DEBUG_LOG_FMT(IOS_USB, "[{:04x}:{:04x} {}] Bulk: length={:04x} endpoint={:02x}", m_vid, m_pid,
+                m_active_interface, cmd->length, cmd->endpoint);
 
   libusb_transfer* transfer = libusb_alloc_transfer(0);
   libusb_fill_bulk_transfer(transfer, m_handle, cmd->endpoint,
@@ -269,8 +270,8 @@ int LibusbDevice::SubmitTransfer(std::unique_ptr<IntrMessage> cmd)
   if (!m_device_attached)
     return LIBUSB_ERROR_NOT_FOUND;
 
-  DEBUG_LOG(IOS_USB, "[%04x:%04x %d] Interrupt: length=%04x endpoint=%02x", m_vid, m_pid,
-            m_active_interface, cmd->length, cmd->endpoint);
+  DEBUG_LOG_FMT(IOS_USB, "[{:04x}:{:04x} {}] Interrupt: length={:04x} endpoint={:02x}", m_vid,
+                m_pid, m_active_interface, cmd->length, cmd->endpoint);
 
   libusb_transfer* transfer = libusb_alloc_transfer(0);
   libusb_fill_interrupt_transfer(transfer, m_handle, cmd->endpoint,
@@ -286,8 +287,9 @@ int LibusbDevice::SubmitTransfer(std::unique_ptr<IsoMessage> cmd)
   if (!m_device_attached)
     return LIBUSB_ERROR_NOT_FOUND;
 
-  DEBUG_LOG(IOS_USB, "[%04x:%04x %d] Isochronous: length=%04x endpoint=%02x num_packets=%02x",
-            m_vid, m_pid, m_active_interface, cmd->length, cmd->endpoint, cmd->num_packets);
+  DEBUG_LOG_FMT(IOS_USB,
+                "[{:04x}:{:04x} {}] Isochronous: length={:04x} endpoint={:02x} num_packets={:02x}",
+                m_vid, m_pid, m_active_interface, cmd->length, cmd->endpoint, cmd->num_packets);
 
   libusb_transfer* transfer = libusb_alloc_transfer(cmd->num_packets);
   transfer->buffer = cmd->MakeBuffer(cmd->length).release();
@@ -360,7 +362,7 @@ void LibusbDevice::TransferEndpoint::HandleTransfer(libusb_transfer* transfer,
   const auto iterator = m_transfers.find(transfer);
   if (iterator == m_transfers.cend())
   {
-    ERROR_LOG(IOS_USB, "No such transfer");
+    ERROR_LOG_FMT(IOS_USB, "No such transfer");
     return;
   }
 
@@ -378,9 +380,10 @@ void LibusbDevice::TransferEndpoint::HandleTransfer(libusb_transfer* transfer,
   case LIBUSB_TRANSFER_TIMED_OUT:
   case LIBUSB_TRANSFER_OVERFLOW:
   case LIBUSB_TRANSFER_STALL:
-    ERROR_LOG(IOS_USB, "[%04x:%04x %d] %s transfer (endpoint 0x%02x) failed: %s", device->m_vid,
-              device->m_pid, device->m_active_interface, s_transfer_types.at(transfer->type),
-              transfer->endpoint, libusb_error_name(transfer->status));
+    ERROR_LOG_FMT(IOS_USB, "[{:04x}:{:04x} {}] {} transfer (endpoint {:#04x}) failed: {}",
+                  device->m_vid, device->m_pid, device->m_active_interface,
+                  s_transfer_types.at(transfer->type), transfer->endpoint,
+                  libusb_error_name(transfer->status));
     return_value = transfer->status == LIBUSB_TRANSFER_STALL ? -7004 : -5;
     break;
   case LIBUSB_TRANSFER_NO_DEVICE:
@@ -396,7 +399,7 @@ void LibusbDevice::TransferEndpoint::CancelTransfers()
   std::lock_guard<std::mutex> lk(m_transfers_mutex);
   if (m_transfers.empty())
     return;
-  INFO_LOG(IOS_USB, "Cancelling %ld transfer(s)", m_transfers.size());
+  INFO_LOG_FMT(IOS_USB, "Cancelling {} transfer(s)", m_transfers.size());
   for (const auto& pending_transfer : m_transfers)
     libusb_cancel_transfer(pending_transfer.first);
 }
@@ -427,16 +430,16 @@ int LibusbDevice::ClaimAllInterfaces(u8 config_num) const
     const int ret2 = libusb_detach_kernel_driver(m_handle, i);
     if (ret2 < 0 && ret2 != LIBUSB_ERROR_NOT_FOUND && ret2 != LIBUSB_ERROR_NOT_SUPPORTED)
     {
-      ERROR_LOG(IOS_USB, "[%04x:%04x] Failed to detach kernel driver: %s", m_vid, m_pid,
-                libusb_error_name(ret2));
+      ERROR_LOG_FMT(IOS_USB, "[{:04x}:{:04x}] Failed to detach kernel driver: {}", m_vid, m_pid,
+                    libusb_error_name(ret2));
       return ret2;
     }
     return libusb_claim_interface(m_handle, i);
   });
   if (ret < 0)
   {
-    ERROR_LOG(IOS_USB, "[%04x:%04x] Failed to claim all interfaces (configuration %u)", m_vid,
-              m_pid, config_num);
+    ERROR_LOG_FMT(IOS_USB, "[{:04x}:{:04x}] Failed to claim all interfaces (configuration {})",
+                  m_vid, m_pid, config_num);
   }
   return ret;
 }
@@ -448,8 +451,8 @@ int LibusbDevice::ReleaseAllInterfaces(u8 config_num) const
   });
   if (ret < 0 && ret != LIBUSB_ERROR_NO_DEVICE && ret != LIBUSB_ERROR_NOT_FOUND)
   {
-    ERROR_LOG(IOS_USB, "[%04x:%04x] Failed to release all interfaces (configuration %u)", m_vid,
-              m_pid, config_num);
+    ERROR_LOG_FMT(IOS_USB, "[{:04x}:{:04x}] Failed to release all interfaces (configuration {})",
+                  m_vid, m_pid, config_num);
   }
   return ret;
 }

diff --git a/Source/Core/Core/IOS/USB/OH0/OH0.cpp b/Source/Core/Core/IOS/USB/OH0/OH0.cpp
@@ -54,7 +54,7 @@ IPCCommandResult OH0::IOCtl(const IOCtlRequest& request)
 
 IPCCommandResult OH0::IOCtlV(const IOCtlVRequest& request)
 {
-  INFO_LOG(IOS_USB, "/dev/usb/oh0 - IOCtlV %u", request.request);
+  INFO_LOG_FMT(IOS_USB, "/dev/usb/oh0 - IOCtlV {}", request.request);
   switch (request.request)
   {
   case USB::IOCTLV_USBV0_GETDEVLIST:
@@ -145,7 +145,7 @@ IPCCommandResult OH0::GetRhPortStatus(const IOCtlVRequest& request) const
   if (!request.HasNumberOfValidVectors(1, 1))
     return GetDefaultReply(IPC_EINVAL);
 
-  ERROR_LOG(IOS_USB, "Unimplemented IOCtlV: IOCTLV_USBV0_GETRHPORTSTATUS");
+  ERROR_LOG_FMT(IOS_USB, "Unimplemented IOCtlV: IOCTLV_USBV0_GETRHPORTSTATUS");
   request.Dump(GetDeviceName(), Common::Log::IOS_USB, Common::Log::LERROR);
   return GetDefaultReply(IPC_SUCCESS);
 }
@@ -155,7 +155,7 @@ IPCCommandResult OH0::SetRhPortStatus(const IOCtlVRequest& request)
   if (!request.HasNumberOfValidVectors(2, 0))
     return GetDefaultReply(IPC_EINVAL);
 
-  ERROR_LOG(IOS_USB, "Unimplemented IOCtlV: IOCTLV_USBV0_SETRHPORTSTATUS");
+  ERROR_LOG_FMT(IOS_USB, "Unimplemented IOCtlV: IOCTLV_USBV0_SETRHPORTSTATUS");
   request.Dump(GetDeviceName(), Common::Log::IOS_USB, Common::Log::LERROR);
   return GetDefaultReply(IPC_SUCCESS);
 }
@@ -208,7 +208,7 @@ IPCCommandResult OH0::RegisterClassChangeHook(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 0))
     return GetDefaultReply(IPC_EINVAL);
-  WARN_LOG(IOS_USB, "Unimplemented IOCtlV: USB::IOCTLV_USBV0_DEVICECLASSCHANGE (no reply)");
+  WARN_LOG_FMT(IOS_USB, "Unimplemented IOCtlV: USB::IOCTLV_USBV0_DEVICECLASSCHANGE (no reply)");
   request.Dump(GetDeviceName(), Common::Log::IOS_USB, Common::Log::LWARNING);
   return GetNoReply();
 }

diff --git a/Source/Core/Core/IOS/USB/USBV5.cpp b/Source/Core/Core/IOS/USB/USBV5.cpp
@@ -169,8 +169,8 @@ IPCCommandResult USBV5ResourceManager::SuspendResume(USBV5Device& device,
 
   // Note: this is unimplemented because there's no easy way to do this in a
   // platform-independant way (libusb does not support power management).
-  INFO_LOG(IOS_USB, "[%04x:%04x %d] Received %s command", host_device->GetVid(),
-           host_device->GetPid(), device.interface_number, resumed == 0 ? "suspend" : "resume");
+  INFO_LOG_FMT(IOS_USB, "[{:04x}:{:04x} {}] Received {} command", host_device->GetVid(),
+               host_device->GetPid(), device.interface_number, resumed == 0 ? "suspend" : "resume");
   return GetDefaultReply(IPC_SUCCESS);
 }
 
@@ -272,7 +272,7 @@ void USBV5ResourceManager::TriggerDeviceChangeReply()
 
   m_ios.EnqueueIPCReply(*m_devicechange_hook_request, num_devices, 0, CoreTiming::FromThread::ANY);
   m_devicechange_hook_request.reset();
-  INFO_LOG(IOS_USB, "%d USBv5 device(s), including interfaces", num_devices);
+  INFO_LOG_FMT(IOS_USB, "{} USBv5 device(s), including interfaces", num_devices);
 }
 }  // namespace Device
 }  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/USB/USB_HID/HIDv4.cpp b/Source/Core/Core/IOS/USB/USB_HID/HIDv4.cpp
@@ -192,7 +192,7 @@ void USB_HIDv4::TriggerDeviceChangeReply()
       const std::vector<u8> device_section = GetDeviceEntry(*device.second.get());
       if (offset + device_section.size() > m_devicechange_hook_request->buffer_out_size - 1)
       {
-        WARN_LOG(IOS_USB, "Too many devices connected, skipping");
+        WARN_LOG_FMT(IOS_USB, "Too many devices connected, skipping");
         break;
       }
       Memory::CopyToEmu(dest + offset, device_section.data(), device_section.size());

diff --git a/Source/Core/Core/IOS/USB/USB_KBD.cpp b/Source/Core/Core/IOS/USB/USB_KBD.cpp
@@ -190,7 +190,7 @@ USB_KBD::USB_KBD(Kernel& ios, const std::string& device_name) : Device(ios, devi
 
 IPCCommandResult USB_KBD::Open(const OpenRequest& request)
 {
-  INFO_LOG(IOS, "USB_KBD: Open");
+  INFO_LOG_FMT(IOS, "USB_KBD: Open");
   IniFile ini;
   ini.Load(File::GetUserPath(F_DOLPHINCONFIG_IDX));
   ini.GetOrCreateSection("USB Keyboard")->Get("Layout", &m_keyboard_layout, KBD_LAYOUT_QWERTY);

diff --git a/Source/Core/Core/IOS/WFS/WFSI.cpp b/Source/Core/Core/IOS/WFS/WFSI.cpp
@@ -4,7 +4,6 @@
 
 #include "Core/IOS/WFS/WFSI.h"
 
-#include <cinttypes>
 #include <mbedtls/aes.h>
 #include <stack>
 #include <string>
@@ -51,10 +50,10 @@ void ARCUnpacker::AddBytes(const std::vector<u8>& bytes)
 
 void ARCUnpacker::Extract(const WriteCallback& callback)
 {
-  u32 fourcc = Common::swap32(m_whole_file.data());
+  const u32 fourcc = Common::swap32(m_whole_file.data());
   if (fourcc != 0x55AA382D)
   {
-    ERROR_LOG(IOS_WFS, "ARCUnpacker: invalid fourcc (%08x)", fourcc);
+    ERROR_LOG_FMT(IOS_WFS, "ARCUnpacker: invalid fourcc ({:08x})", fourcc);
     return;
   }
 
@@ -135,14 +134,14 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
   {
   case IOCTL_WFSI_IMPORT_TITLE_INIT:
   {
-    u32 tmd_addr = Memory::Read_U32(request.buffer_in);
-    u32 tmd_size = Memory::Read_U32(request.buffer_in + 4);
+    const u32 tmd_addr = Memory::Read_U32(request.buffer_in);
+    const u32 tmd_size = Memory::Read_U32(request.buffer_in + 4);
 
     m_patch_type = static_cast<PatchType>(Memory::Read_U32(request.buffer_in + 32));
     m_continue_install = Memory::Read_U32(request.buffer_in + 36);
 
-    INFO_LOG(IOS_WFS, "IOCTL_WFSI_IMPORT_TITLE_INIT: patch type %d, continue install: %s",
-             m_patch_type, m_continue_install ? "true" : "false");
+    INFO_LOG_FMT(IOS_WFS, "IOCTL_WFSI_IMPORT_TITLE_INIT: patch type {}, continue install: {}",
+                 m_patch_type, m_continue_install ? "true" : "false");
 
     if (m_patch_type == PatchType::PATCH_TYPE_2)
     {
@@ -155,7 +154,7 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
 
     if (!IOS::ES::IsValidTMDSize(tmd_size))
     {
-      ERROR_LOG(IOS_WFS, "IOCTL_WFSI_IMPORT_TITLE_INIT: TMD size too large (%d)", tmd_size);
+      ERROR_LOG_FMT(IOS_WFS, "IOCTL_WFSI_IMPORT_TITLE_INIT: TMD size too large ({})", tmd_size);
       return_error_code = IPC_EINVAL;
       break;
     }
@@ -164,7 +163,7 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
     Memory::CopyFromEmu(tmd_bytes.data(), tmd_addr, tmd_size);
     m_tmd.SetBytes(std::move(tmd_bytes));
 
-    IOS::ES::TicketReader ticket = m_ios.GetES()->FindSignedTicket(m_tmd.GetTitleId());
+    const IOS::ES::TicketReader ticket = m_ios.GetES()->FindSignedTicket(m_tmd.GetTitleId());
     if (!ticket.IsValid())
     {
       return_error_code = -11028;
@@ -195,20 +194,20 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
                                  "IOCTL_WFSI_PREPARE_CONTENT";
 
     // Initializes the IV from the index of the content in the TMD contents.
-    u32 content_id = Memory::Read_U32(request.buffer_in + 8);
+    const u32 content_id = Memory::Read_U32(request.buffer_in + 8);
     IOS::ES::Content content_info;
     if (!m_tmd.FindContentById(content_id, &content_info))
     {
-      WARN_LOG(IOS_WFS, "%s: Content id %08x not found", ioctl_name, content_id);
+      WARN_LOG_FMT(IOS_WFS, "{}: Content id {:08x} not found", ioctl_name, content_id);
       return_error_code = -10003;
       break;
     }
 
     memset(m_aes_iv, 0, sizeof(m_aes_iv));
     m_aes_iv[0] = content_info.index >> 8;
     m_aes_iv[1] = content_info.index & 0xFF;
-    INFO_LOG(IOS_WFS, "%s: Content id %08x found at index %d", ioctl_name, content_id,
-             content_info.index);
+    INFO_LOG_FMT(IOS_WFS, "{}: Content id {:08x} found at index {}", ioctl_name, content_id,
+                 content_info.index);
 
     m_arc_unpacker.Reset();
     break;
@@ -221,11 +220,11 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
                                  "IOCTL_WFSI_IMPORT_PROFILE" :
                                  "IOCTL_WFSI_IMPORT_CONTENT";
 
-    u32 content_id = Memory::Read_U32(request.buffer_in + 0xC);
-    u32 input_ptr = Memory::Read_U32(request.buffer_in + 0x10);
-    u32 input_size = Memory::Read_U32(request.buffer_in + 0x14);
-    INFO_LOG(IOS_WFS, "%s: %08x bytes of data at %08x from content id %d", ioctl_name, input_size,
-             input_ptr, content_id);
+    const u32 content_id = Memory::Read_U32(request.buffer_in + 0xC);
+    const u32 input_ptr = Memory::Read_U32(request.buffer_in + 0x10);
+    const u32 input_size = Memory::Read_U32(request.buffer_in + 0x14);
+    INFO_LOG_FMT(IOS_WFS, "{}: {:08x} bytes of data at {:08x} from content id {}", ioctl_name,
+                 input_size, input_ptr, content_id);
 
     std::vector<u8> decrypted(input_size);
     mbedtls_aes_crypt_cbc(&m_aes_ctx, MBEDTLS_AES_DECRYPT, input_size, m_aes_iv,
@@ -241,17 +240,17 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
     const char* ioctl_name = request.request == IOCTL_WFSI_IMPORT_PROFILE_END ?
                                  "IOCTL_WFSI_IMPORT_PROFILE_END" :
                                  "IOCTL_WFSI_IMPORT_CONTENT_END";
-    INFO_LOG(IOS_WFS, "%s", ioctl_name);
+    INFO_LOG_FMT(IOS_WFS, "{}", ioctl_name);
 
-    auto callback = [this](const std::string& filename, const std::vector<u8>& bytes) {
-      INFO_LOG(IOS_WFS, "Extract: %s (%zd bytes)", filename.c_str(), bytes.size());
+    const auto callback = [this](const std::string& filename, const std::vector<u8>& bytes) {
+      INFO_LOG_FMT(IOS_WFS, "Extract: {} ({} bytes)", filename, bytes.size());
 
-      std::string path = WFS::NativePath(m_base_extract_path + "/" + filename);
+      const std::string path = WFS::NativePath(m_base_extract_path + '/' + filename);
       File::CreateFullPath(path);
       File::IOFile f(path, "wb");
       if (!f)
       {
-        ERROR_LOG(IOS_WFS, "Could not extract %s to %s", filename.c_str(), path.c_str());
+        ERROR_LOG_FMT(IOS_WFS, "Could not extract {} to {}", filename, path);
         return;
       }
       f.WriteBytes(bytes.data(), bytes.size());
@@ -321,7 +320,7 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
 
   case IOCTL_WFSI_FINALIZE_PATCH_INSTALL:
   {
-    INFO_LOG(IOS_WFS, "IOCTL_WFSI_FINALIZE_PATCH_INSTALL");
+    INFO_LOG_FMT(IOS_WFS, "IOCTL_WFSI_FINALIZE_PATCH_INSTALL");
     if (m_patch_type != NOT_A_PATCH)
       FinalizePatchInstall();
     break;
@@ -331,13 +330,13 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
     // Bytes 0-4: ??
     // Bytes 4-8: game id
     // Bytes 1c-1e: title id?
-    WARN_LOG(IOS_WFS, "IOCTL_WFSI_DELETE_TITLE: unimplemented");
+    WARN_LOG_FMT(IOS_WFS, "IOCTL_WFSI_DELETE_TITLE: unimplemented");
     break;
 
   case IOCTL_WFSI_CHANGE_TITLE:
   {
-    u64 title_id = Memory::Read_U64(request.buffer_in);
-    u16 group_id = Memory::Read_U16(request.buffer_in + 0x1C);
+    const u64 title_id = Memory::Read_U64(request.buffer_in);
+    const u16 group_id = Memory::Read_U16(request.buffer_in + 0x1C);
 
     // TODO: Handle permissions
     SetCurrentTitleIdAndGroupId(title_id, group_id);
@@ -346,8 +345,8 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
     const std::string homedir_path = fmt::format("/vol/{}/title/{}/{}/", m_device_name,
                                                  m_current_group_id_str, m_current_title_id_str);
     const u16 homedir_path_len = static_cast<u16>(homedir_path.size());
-    INFO_LOG(IOS_WFS, "IOCTL_WFSI_CHANGE_TITLE: %s (path_len: 0x%x)", homedir_path.c_str(),
-             homedir_path_len);
+    INFO_LOG_FMT(IOS_WFS, "IOCTL_WFSI_CHANGE_TITLE: {} (path_len: {:#x})", homedir_path,
+                 homedir_path_len);
 
     return_error_code = -3;
     if (homedir_path_len > 0x1FD)
@@ -361,15 +360,15 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
   }
 
   case IOCTL_WFSI_GET_VERSION:
-    INFO_LOG(IOS_WFS, "IOCTL_WFSI_GET_VERSION");
+    INFO_LOG_FMT(IOS_WFS, "IOCTL_WFSI_GET_VERSION");
     Memory::Write_U32(0x20, request.buffer_out);
     break;
 
   case IOCTL_WFSI_IMPORT_TITLE_CANCEL:
   {
-    INFO_LOG(IOS_WFS, "IOCTL_WFSI_IMPORT_TITLE_CANCEL");
+    INFO_LOG_FMT(IOS_WFS, "IOCTL_WFSI_IMPORT_TITLE_CANCEL");
 
-    bool continue_install = Memory::Read_U32(request.buffer_in) != 0;
+    const bool continue_install = Memory::Read_U32(request.buffer_in) != 0;
     if (m_patch_type == PatchType::NOT_A_PATCH)
       return_error_code = CancelTitleImport(continue_install);
     else if (m_patch_type == PatchType::PATCH_TYPE_1 || m_patch_type == PatchType::PATCH_TYPE_2)
@@ -383,28 +382,28 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
 
   case IOCTL_WFSI_INIT:
   {
-    INFO_LOG(IOS_WFS, "IOCTL_WFSI_INIT");
+    INFO_LOG_FMT(IOS_WFS, "IOCTL_WFSI_INIT");
     u64 tid;
     if (GetIOS()->GetES()->GetTitleId(&tid) < 0)
     {
-      ERROR_LOG(IOS_WFS, "IOCTL_WFSI_INIT: Could not get title id.");
+      ERROR_LOG_FMT(IOS_WFS, "IOCTL_WFSI_INIT: Could not get title id.");
       return_error_code = IPC_EINVAL;
       break;
     }
 
-    IOS::ES::TMDReader tmd = GetIOS()->GetES()->FindInstalledTMD(tid);
+    const IOS::ES::TMDReader tmd = GetIOS()->GetES()->FindInstalledTMD(tid);
     SetCurrentTitleIdAndGroupId(tmd.GetTitleId(), tmd.GetGroupId());
     break;
   }
 
   case IOCTL_WFSI_SET_DEVICE_NAME:
-    INFO_LOG(IOS_WFS, "IOCTL_WFSI_SET_DEVICE_NAME");
+    INFO_LOG_FMT(IOS_WFS, "IOCTL_WFSI_SET_DEVICE_NAME");
     m_device_name = Memory::GetString(request.buffer_in);
     break;
 
   case IOCTL_WFSI_APPLY_TITLE_PROFILE:
   {
-    INFO_LOG(IOS_WFS, "IOCTL_WFSI_APPLY_TITLE_PROFILE");
+    INFO_LOG_FMT(IOS_WFS, "IOCTL_WFSI_APPLY_TITLE_PROFILE");
 
     if (m_patch_type == NOT_A_PATCH)
     {
@@ -443,9 +442,9 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
 
   case IOCTL_WFSI_GET_TMD:
   {
-    u64 subtitle_id = Memory::Read_U64(request.buffer_in);
-    u32 address = Memory::Read_U32(request.buffer_in + 24);
-    INFO_LOG(IOS_WFS, "IOCTL_WFSI_GET_TMD: subtitle ID %016" PRIx64, subtitle_id);
+    const u64 subtitle_id = Memory::Read_U64(request.buffer_in);
+    const u32 address = Memory::Read_U32(request.buffer_in + 24);
+    INFO_LOG_FMT(IOS_WFS, "IOCTL_WFSI_GET_TMD: subtitle ID {:016x}", subtitle_id);
 
     u32 tmd_size;
     return_error_code =
@@ -456,12 +455,13 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
 
   case IOCTL_WFSI_GET_TMD_ABSOLUTE:
   {
-    u64 subtitle_id = Memory::Read_U64(request.buffer_in);
-    u32 address = Memory::Read_U32(request.buffer_in + 24);
-    u16 group_id = Memory::Read_U16(request.buffer_in + 36);
-    u32 title_id = Memory::Read_U32(request.buffer_in + 32);
-    INFO_LOG(IOS_WFS, "IOCTL_WFSI_GET_TMD_ABSOLUTE: tid %08x, gid %04x, subtitle ID %016" PRIx64,
-             title_id, group_id, subtitle_id);
+    const u64 subtitle_id = Memory::Read_U64(request.buffer_in);
+    const u32 address = Memory::Read_U32(request.buffer_in + 24);
+    const u16 group_id = Memory::Read_U16(request.buffer_in + 36);
+    const u32 title_id = Memory::Read_U32(request.buffer_in + 32);
+    INFO_LOG_FMT(IOS_WFS,
+                 "IOCTL_WFSI_GET_TMD_ABSOLUTE: tid {:08x}, gid {:04x}, subtitle ID {:016x}",
+                 title_id, group_id, subtitle_id);
 
     u32 tmd_size;
     return_error_code = GetTmd(group_id, title_id, subtitle_id, address, &tmd_size);
@@ -471,8 +471,8 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
 
   case IOCTL_WFSI_SET_FST_BUFFER:
   {
-    INFO_LOG(IOS_WFS, "IOCTL_WFSI_SET_FST_BUFFER: address %08x, size %08x", request.buffer_in,
-             request.buffer_in_size);
+    INFO_LOG_FMT(IOS_WFS, "IOCTL_WFSI_SET_FST_BUFFER: address {:08x}, size {:08x}",
+                 request.buffer_in, request.buffer_in_size);
     break;
   }
 
@@ -497,18 +497,18 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
       path += fmt::format("/extension{}.dol", dol_extension_id);
     }
 
-    INFO_LOG(IOS_WFS, "IOCTL_WFSI_LOAD_DOL: loading %s at address %08x (size %d)", path.c_str(),
-             dol_addr, max_dol_size);
+    INFO_LOG_FMT(IOS_WFS, "IOCTL_WFSI_LOAD_DOL: loading {} at address {:08x} (size {})", path,
+                 dol_addr, max_dol_size);
 
     File::IOFile fp(WFS::NativePath(path), "rb");
     if (!fp)
     {
-      WARN_LOG(IOS_WFS, "IOCTL_WFSI_LOAD_DOL: no such file or directory: %s", path.c_str());
+      WARN_LOG_FMT(IOS_WFS, "IOCTL_WFSI_LOAD_DOL: no such file or directory: {}", path);
       return_error_code = WFS_ENOENT;
       break;
     }
 
-    u32 real_dol_size = fp.GetSize();
+    const auto real_dol_size = static_cast<u32>(fp.GetSize());
     if (dol_addr == 0)
     {
       // Write the expected size to the size parameter, in the input.
@@ -523,7 +523,7 @@ IPCCommandResult WFSI::IOCtl(const IOCtlRequest& request)
   }
 
   case IOCTL_WFSI_CHECK_HAS_SPACE:
-    WARN_LOG(IOS_WFS, "IOCTL_WFSI_CHECK_HAS_SPACE: returning true");
+    WARN_LOG_FMT(IOS_WFS, "IOCTL_WFSI_CHECK_HAS_SPACE: returning true");
 
     // TODO(wfs): implement this properly.
     //       1 is returned if there is free space, 0 otherwise.
@@ -558,7 +558,7 @@ u32 WFSI::GetTmd(u16 group_id, u32 title_id, u64 subtitle_id, u32 address, u32*
   File::IOFile fp(WFS::NativePath(path), "rb");
   if (!fp)
   {
-    WARN_LOG(IOS_WFS, "GetTmd: no such file or directory: %s", path.c_str());
+    WARN_LOG_FMT(IOS_WFS, "GetTmd: no such file or directory: {}", path);
     return WFS_ENOENT;
   }
   if (address)