diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7bab1f6ebb7..94464907de1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -378,13 +378,16 @@ endif()
 target_link_options(sanitize_interface INTERFACE ${SANITIZER_LDFLAGS})
 
 if(BUILD_FUZZ_BINARY)
-  include(CheckSourceCompilesAndLinks)
-  check_cxx_source_links_with_flags("${SANITIZER_LDFLAGS}" "
+  target_link_libraries(core_interface INTERFACE ${FUZZ_LIBS})
+  include(CheckSourceCompilesWithFlags)
+  check_cxx_source_compiles_with_flags("
       #include <cstdint>
       #include <cstddef>
       extern \"C\" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { return 0; }
       // No main() function.
     " FUZZ_BINARY_LINKS_WITHOUT_MAIN_FUNCTION
+    LDFLAGS ${SANITIZER_LDFLAGS}
+    LINK_LIBRARIES ${FUZZ_LIBS}
   )
 endif()
 
diff --git a/cmake/crc32c.cmake b/cmake/crc32c.cmake
index 529f94ccfd4..25f046bb43a 100644
--- a/cmake/crc32c.cmake
+++ b/cmake/crc32c.cmake
@@ -7,6 +7,7 @@
 # buildsystem.
 
 include(CheckCXXSourceCompiles)
+include(CheckSourceCompilesWithFlags)
 
 # Check for __builtin_prefetch support in the compiler.
 check_cxx_source_compiles("
@@ -42,7 +43,7 @@ if(MSVC)
 else()
   set(SSE42_CXXFLAGS -msse4.2)
 endif()
-check_cxx_source_compiles_with_flags("${SSE42_CXXFLAGS}" "
+check_cxx_source_compiles_with_flags("
   #include <cstdint>
   #if defined(_MSC_VER)
   #include <intrin.h>
@@ -58,11 +59,12 @@ check_cxx_source_compiles_with_flags("${SSE42_CXXFLAGS}" "
     return l;
   }
   " HAVE_SSE42
+  CXXFLAGS ${SSE42_CXXFLAGS}
 )
 
 # Check for ARMv8 w/ CRC and CRYPTO extensions support in the compiler.
 set(ARM64_CRC_CXXFLAGS -march=armv8-a+crc+crypto)
-check_cxx_source_compiles_with_flags("${ARM64_CRC_CXXFLAGS}" "
+check_cxx_source_compiles_with_flags("
   #include <arm_acle.h>
   #include <arm_neon.h>
 
@@ -76,6 +78,7 @@ check_cxx_source_compiles_with_flags("${ARM64_CRC_CXXFLAGS}" "
     return 0;
   }
   " HAVE_ARM64_CRC32C
+  CXXFLAGS ${ARM64_CRC_CXXFLAGS}
 )
 
 add_library(crc32c STATIC EXCLUDE_FROM_ALL
diff --git a/cmake/introspection.cmake b/cmake/introspection.cmake
index 29c93869a73..d4ed4866b9c 100644
--- a/cmake/introspection.cmake
+++ b/cmake/introspection.cmake
@@ -160,11 +160,11 @@ check_cxx_source_compiles("
 )
 
 if(NOT MSVC)
-  include(CheckSourceCompilesAndLinks)
+  include(CheckSourceCompilesWithFlags)
 
   # Check for SSE4.1 intrinsics.
   set(SSE41_CXXFLAGS -msse4.1)
-  check_cxx_source_compiles_with_flags("${SSE41_CXXFLAGS}" "
+  check_cxx_source_compiles_with_flags("
     #include <immintrin.h>
 
     int main()
@@ -175,12 +175,13 @@ if(NOT MSVC)
       return _mm_extract_epi32(r, 3);
     }
     " HAVE_SSE41
+    CXXFLAGS ${SSE41_CXXFLAGS}
   )
   set(ENABLE_SSE41 ${HAVE_SSE41})
 
   # Check for AVX2 intrinsics.
   set(AVX2_CXXFLAGS -mavx -mavx2)
-  check_cxx_source_compiles_with_flags("${AVX2_CXXFLAGS}" "
+  check_cxx_source_compiles_with_flags("
     #include <immintrin.h>
 
     int main()
@@ -189,12 +190,13 @@ if(NOT MSVC)
       return _mm256_extract_epi32(l, 7);
     }
     " HAVE_AVX2
+    CXXFLAGS ${AVX2_CXXFLAGS}
   )
   set(ENABLE_AVX2 ${HAVE_AVX2})
 
   # Check for x86 SHA-NI intrinsics.
   set(X86_SHANI_CXXFLAGS -msse4 -msha)
-  check_cxx_source_compiles_with_flags("${X86_SHANI_CXXFLAGS}" "
+  check_cxx_source_compiles_with_flags("
     #include <immintrin.h>
 
     int main()
@@ -205,12 +207,13 @@ if(NOT MSVC)
       return _mm_extract_epi32(_mm_sha256rnds2_epu32(i, j, k), 0);
     }
     " HAVE_X86_SHANI
+    CXXFLAGS ${X86_SHANI_CXXFLAGS}
   )
   set(ENABLE_X86_SHANI ${HAVE_X86_SHANI})
 
   # Check for ARMv8 SHA-NI intrinsics.
   set(ARM_SHANI_CXXFLAGS -march=armv8-a+crypto)
-  check_cxx_source_compiles_with_flags("${ARM_SHANI_CXXFLAGS}" "
+  check_cxx_source_compiles_with_flags("
     #include <arm_neon.h>
 
     int main()
@@ -222,6 +225,7 @@ if(NOT MSVC)
       vsha256su1q_u32(a, b, c);
     }
     " HAVE_ARM_SHANI
+    CXXFLAGS ${ARM_SHANI_CXXFLAGS}
   )
   set(ENABLE_ARM_SHANI ${HAVE_ARM_SHANI})
 endif()
diff --git a/cmake/minisketch.cmake b/cmake/minisketch.cmake
index 7407739ed94..102097aacb4 100644
--- a/cmake/minisketch.cmake
+++ b/cmake/minisketch.cmake
@@ -2,13 +2,15 @@
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or https://opensource.org/license/mit/.
 
+include(CheckSourceCompilesWithFlags)
+
 # Check for clmul instructions support.
 if(MSVC)
-  set(CLMUL_CXXFLAGS)
+  set(CLMUL_CXXFLAGS "")
 else()
   set(CLMUL_CXXFLAGS -mpclmul)
 endif()
-check_cxx_source_compiles_with_flags("${CLMUL_CXXFLAGS}" "
+check_cxx_source_compiles_with_flags("
   #include <immintrin.h>
   #include <cstdint>
 
@@ -22,6 +24,7 @@ check_cxx_source_compiles_with_flags("${CLMUL_CXXFLAGS}" "
     return e == 0;
   }
   " HAVE_CLMUL
+  CXXFLAGS ${CLMUL_CXXFLAGS}
 )
 
 add_library(minisketch_common INTERFACE)
diff --git a/cmake/module/CheckSourceCompilesAndLinks.cmake b/cmake/module/CheckSourceCompilesAndLinks.cmake
deleted file mode 100644
index 88c897d5243..00000000000
--- a/cmake/module/CheckSourceCompilesAndLinks.cmake
+++ /dev/null
@@ -1,39 +0,0 @@
-# Copyright (c) 2023-present The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or https://opensource.org/license/mit/.
-
-include_guard(GLOBAL)
-include(CheckCXXSourceCompiles)
-include(CMakePushCheckState)
-
-# This avoids running the linker.
-set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
-
-macro(check_cxx_source_links source)
-  set(CMAKE_TRY_COMPILE_TARGET_TYPE EXECUTABLE)
-  check_cxx_source_compiles("${source}" ${ARGN})
-  set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
-endmacro()
-
-macro(check_cxx_source_compiles_with_flags flags source)
-  cmake_push_check_state(RESET)
-  set(CMAKE_REQUIRED_FLAGS ${flags})
-  list(JOIN CMAKE_REQUIRED_FLAGS " " CMAKE_REQUIRED_FLAGS)
-  check_cxx_source_compiles("${source}" ${ARGN})
-  cmake_pop_check_state()
-endmacro()
-
-macro(check_cxx_source_links_with_flags flags source)
-  cmake_push_check_state(RESET)
-  set(CMAKE_REQUIRED_FLAGS ${flags})
-  list(JOIN CMAKE_REQUIRED_FLAGS " " CMAKE_REQUIRED_FLAGS)
-  check_cxx_source_links("${source}" ${ARGN})
-  cmake_pop_check_state()
-endmacro()
-
-macro(check_cxx_source_links_with_libs libs source)
-  cmake_push_check_state(RESET)
-  set(CMAKE_REQUIRED_LIBRARIES "${libs}")
-  check_cxx_source_links("${source}" ${ARGN})
-  cmake_pop_check_state()
-endmacro()
diff --git a/cmake/module/CheckSourceCompilesWithFlags.cmake b/cmake/module/CheckSourceCompilesWithFlags.cmake
new file mode 100644
index 00000000000..02bd7265bf7
--- /dev/null
+++ b/cmake/module/CheckSourceCompilesWithFlags.cmake
@@ -0,0 +1,34 @@
+# Copyright (c) 2023-present The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or https://opensource.org/license/mit/.
+
+include_guard(GLOBAL)
+
+#[=[
+Check once if C++ source code can be compiled.
+
+Options:
+
+  CXXFLAGS - A list of additional flags to pass to the compiler.
+
+  LDFLAGS - A list of additional flags to pass to the linker.
+
+  LINK_LIBRARIES - A list of libraries to add to the link command.
+
+For historical reasons, among the CMake `CMAKE_REQUIRED_*` variables that influence
+`check_cxx_source_compiles()`, only `CMAKE_REQUIRED_FLAGS` is a string rather than
+a list. Additionally, `target_compile_options()` also expects a list of options.
+
+The `check_cxx_source_compiles_with_flags()` function handles this case and accepts
+`CXXFLAGS` as a list, simplifying the code at the caller site.
+
+#]=]
+function(check_cxx_source_compiles_with_flags source result_var)
+  cmake_parse_arguments(PARSE_ARGV 2 _ "" "" "CXXFLAGS;LDFLAGS;LINK_LIBRARIES")
+  list(JOIN __CXXFLAGS " " CMAKE_REQUIRED_FLAGS)
+  set(CMAKE_REQUIRED_LINK_OPTIONS ${__LDFLAGS})
+  set(CMAKE_REQUIRED_LIBRARIES ${__LINK_LIBRARIES})
+  include(CheckCXXSourceCompiles)
+  check_cxx_source_compiles("${source}" ${result_var})
+  set(${result_var} ${${result_var}} PARENT_SCOPE)
+endfunction()
diff --git a/cmake/module/TestAppendRequiredLibraries.cmake b/cmake/module/TestAppendRequiredLibraries.cmake
index 5352102c7a4..e15c2b9934d 100644
--- a/cmake/module/TestAppendRequiredLibraries.cmake
+++ b/cmake/module/TestAppendRequiredLibraries.cmake
@@ -25,10 +25,13 @@ function(test_append_socket_library target)
     }
   ")
 
-  include(CheckSourceCompilesAndLinks)
-  check_cxx_source_links("${check_socket_source}" IFADDR_LINKS_WITHOUT_LIBSOCKET)
+  include(CheckCXXSourceCompiles)
+  check_cxx_source_compiles("${check_socket_source}" IFADDR_LINKS_WITHOUT_LIBSOCKET)
   if(NOT IFADDR_LINKS_WITHOUT_LIBSOCKET)
-    check_cxx_source_links_with_libs(socket "${check_socket_source}" IFADDR_NEEDS_LINK_TO_LIBSOCKET)
+    include(CheckSourceCompilesWithFlags)
+    check_cxx_source_compiles_with_flags("${check_socket_source}" IFADDR_NEEDS_LINK_TO_LIBSOCKET
+      LINK_LIBRARIES socket
+    )
     if(IFADDR_NEEDS_LINK_TO_LIBSOCKET)
       target_link_libraries(${target} INTERFACE socket)
     else()
@@ -77,16 +80,17 @@ function(test_append_atomic_library target)
     }
   ")
 
-  include(CheckSourceCompilesAndLinks)
-  check_cxx_source_links("${check_atomic_source}" STD_ATOMIC_LINKS_WITHOUT_LIBATOMIC)
-  if(STD_ATOMIC_LINKS_WITHOUT_LIBATOMIC)
-    return()
-  endif()
-
-  check_cxx_source_links_with_libs(atomic "${check_atomic_source}" STD_ATOMIC_NEEDS_LINK_TO_LIBATOMIC)
-  if(STD_ATOMIC_NEEDS_LINK_TO_LIBATOMIC)
-    target_link_libraries(${target} INTERFACE atomic)
-  else()
-    message(FATAL_ERROR "Cannot figure out how to use std::atomic.")
+  include(CheckCXXSourceCompiles)
+  check_cxx_source_compiles("${check_atomic_source}" STD_ATOMIC_LINKS_WITHOUT_LIBATOMIC)
+  if(NOT STD_ATOMIC_LINKS_WITHOUT_LIBATOMIC)
+    include(CheckSourceCompilesWithFlags)
+    check_cxx_source_compiles_with_flags("${check_atomic_source}" STD_ATOMIC_NEEDS_LINK_TO_LIBATOMIC
+      LINK_LIBRARIES atomic
+    )
+    if(STD_ATOMIC_NEEDS_LINK_TO_LIBATOMIC)
+      target_link_libraries(${target} INTERFACE atomic)
+    else()
+      message(FATAL_ERROR "Cannot figure out how to use std::atomic.")
+    endif()
   endif()
 endfunction()