diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Eventing/NativeRuntimeEventSource.Threading.NativeSinks.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Eventing/NativeRuntimeEventSource.Threading.NativeSinks.CoreCLR.cs
index 511476e789fe2..95942b6291c36 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Eventing/NativeRuntimeEventSource.Threading.NativeSinks.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Eventing/NativeRuntimeEventSource.Threading.NativeSinks.CoreCLR.cs
@@ -97,5 +97,18 @@ private static partial void LogThreadPoolIOPack(
             IntPtr NativeOverlapped,
             IntPtr Overlapped,
             ushort ClrInstanceID);
+
+#pragma warning disable IDE0060 // Remove unused parameter
+        [NonEvent]
+        private static void LogWaitHandleWaitStart(
+            WaitHandleWaitSourceMap WaitSource,
+            IntPtr AssociatedObjectID,
+            ushort ClrInstanceID) =>
+            Debug.Fail("This event is currently not expected to be raised by managed code in CoreCLR.");
+
+        [NonEvent]
+        private static void LogWaitHandleWaitStop(ushort ClrInstanceID) =>
+            Debug.Fail("This event is currently not expected to be raised by managed code in CoreCLR.");
+#pragma warning restore IDE0060
     }
 }
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/WaitHandle.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/WaitHandle.CoreCLR.cs
index f25dd2c124f73..1427473092185 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Threading/WaitHandle.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/WaitHandle.CoreCLR.cs
@@ -11,7 +11,7 @@ public abstract partial class WaitHandle
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern int WaitOneCore(IntPtr waitHandle, int millisecondsTimeout);
 
-        internal static unsafe int WaitMultipleIgnoringSyncContext(Span<IntPtr> waitHandles, bool waitAll, int millisecondsTimeout)
+        private static unsafe int WaitMultipleIgnoringSyncContextCore(Span<IntPtr> waitHandles, bool waitAll, int millisecondsTimeout)
         {
             fixed (IntPtr* pWaitHandles = &MemoryMarshal.GetReference(waitHandles))
             {
diff --git a/src/coreclr/gc/env/etmdummy.h b/src/coreclr/gc/env/etmdummy.h
index 443e9e21e0941..37e0506374a5e 100644
--- a/src/coreclr/gc/env/etmdummy.h
+++ b/src/coreclr/gc/env/etmdummy.h
@@ -417,3 +417,5 @@
 #define FireEtwAppDomainAssemblyResolveHandlerInvoked(ClrInstanceId, assemblyName, handlerName, resultAssemblyName, resultAssemblyPath) 0
 #define FireEtwAssemblyLoadFromResolveHandlerInvoked(ClrInstanceId, assemblyName, isTrackedAssembly, requestingAssemblyPath, requestedAssemblyPath) 0
 #define FireEtwEventSource(eventID, eventName, eventSourceName, payload) 0
+#define FireEtwWaitHandleWaitStart(WaitSource, AssociatedObjectID, ClrInstanceID) 0
+#define FireEtwWaitHandleWaitStop(ClrInstanceID) 0
diff --git a/src/coreclr/inc/eventtracebase.h b/src/coreclr/inc/eventtracebase.h
index 3648b1f3a7213..3fa3903b05811 100644
--- a/src/coreclr/inc/eventtracebase.h
+++ b/src/coreclr/inc/eventtracebase.h
@@ -1153,6 +1153,19 @@ namespace ETW
             } ContentionFlags;
         } ContentionStructs;
     };
+
+    class WaitHandleLog
+    {
+    public:
+        typedef union _WaitHandleStructs
+        {
+            typedef  enum _WaitSource {
+                Unknown=0,
+                MonitorWait=1
+            } WaitSource;
+        } WaitHandleStructs;
+    };
+
     // Class to wrap all Interop logic for ETW
     class InteropLog
     {
diff --git a/src/coreclr/nativeaot/Runtime/disabledruntimeeventinternal.cpp b/src/coreclr/nativeaot/Runtime/disabledruntimeeventinternal.cpp
index 6b3e76f6dde1c..17a8010ec1cde 100644
--- a/src/coreclr/nativeaot/Runtime/disabledruntimeeventinternal.cpp
+++ b/src/coreclr/nativeaot/Runtime/disabledruntimeeventinternal.cpp
@@ -84,4 +84,12 @@ EXTERN_C NATIVEAOT_API void __cdecl NativeRuntimeEventSource_LogExceptionThrown(
 {
 }
 
+EXTERN_C NATIVEAOT_API void __cdecl NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID)
+{
+}
+
+EXTERN_C NATIVEAOT_API void __cdecl NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID)
+{
+}
+
 #endif // FEATURE_PERFTRACING
diff --git a/src/coreclr/nativeaot/Runtime/eventpipe/gen-eventing-event-inc.lst b/src/coreclr/nativeaot/Runtime/eventpipe/gen-eventing-event-inc.lst
index bd8955be9ed59..5abd0e3866926 100644
--- a/src/coreclr/nativeaot/Runtime/eventpipe/gen-eventing-event-inc.lst
+++ b/src/coreclr/nativeaot/Runtime/eventpipe/gen-eventing-event-inc.lst
@@ -110,3 +110,5 @@ ThreadPoolWorkerThreadStop
 ThreadPoolWorkerThreadWait
 ThreadPoolWorkingThreadCount
 ThreadRunning
+WaitHandleWaitStart
+WaitHandleWaitStop
diff --git a/src/coreclr/nativeaot/Runtime/runtimeeventinternal.cpp b/src/coreclr/nativeaot/Runtime/runtimeeventinternal.cpp
index b346ef52d3351..7b4afafd8671f 100644
--- a/src/coreclr/nativeaot/Runtime/runtimeeventinternal.cpp
+++ b/src/coreclr/nativeaot/Runtime/runtimeeventinternal.cpp
@@ -100,4 +100,14 @@ EXTERN_C NATIVEAOT_API void __cdecl NativeRuntimeEventSource_LogExceptionThrown(
         GetClrInstanceId());
 }
 
+EXTERN_C NATIVEAOT_API void __cdecl NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID)
+{
+    FireEtwWaitHandleWaitStart(WaitSource, reinterpret_cast<const void*>(AssociatedObjectID), ClrInstanceID);
+}
+
+EXTERN_C NATIVEAOT_API void __cdecl NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID)
+{
+    FireEtwWaitHandleWaitStop(ClrInstanceID);
+}
+
 #endif // FEATURE_PERFTRACING
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Diagnostics/Eventing/NativeRuntimeEventSource.Threading.NativeSinks.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Diagnostics/Eventing/NativeRuntimeEventSource.Threading.NativeSinks.NativeAot.cs
index 69e0dbadf06f3..7f214ab0b2bb6 100644
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Diagnostics/Eventing/NativeRuntimeEventSource.Threading.NativeSinks.NativeAot.cs
+++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Diagnostics/Eventing/NativeRuntimeEventSource.Threading.NativeSinks.NativeAot.cs
@@ -22,6 +22,7 @@ public static partial class Keywords
             public const EventKeywords ContentionKeyword = (EventKeywords)0x4000;
             public const EventKeywords ThreadingKeyword = (EventKeywords)0x10000;
             public const EventKeywords ThreadTransferKeyword = (EventKeywords)0x80000000;
+            public const EventKeywords WaitHandleKeyword = (EventKeywords)0x40000000000;
         }
 
         [NonEvent]
@@ -132,5 +133,20 @@ internal static void LogThreadPoolIOPack(
         {
             RuntimeImports.NativeRuntimeEventSource_LogThreadPoolIOPack(NativeOverlapped, Overlapped, ClrInstanceID);
         }
+
+        [NonEvent]
+        internal static void LogWaitHandleWaitStart(
+            WaitHandleWaitSourceMap WaitSource,
+            IntPtr AssociatedObjectID,
+            ushort ClrInstanceID)
+        {
+            RuntimeImports.NativeRuntimeEventSource_LogWaitHandleWaitStart((byte)WaitSource, AssociatedObjectID, ClrInstanceID);
+        }
+
+        [NonEvent]
+        internal static void LogWaitHandleWaitStop(ushort ClrInstanceID)
+        {
+            RuntimeImports.NativeRuntimeEventSource_LogWaitHandleWaitStop(ClrInstanceID);
+        }
     }
 }
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs
index 733fdece37f1c..33dbf18e3d8d9 100644
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs
+++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs
@@ -826,6 +826,17 @@ internal static partial void NativeRuntimeEventSource_LogThreadPoolIOPack(
         [LibraryImport(RuntimeLibrary)]
         [UnmanagedCallConv(CallConvs = new Type[] { typeof(CallConvCdecl) })]
         internal static unsafe partial void NativeRuntimeEventSource_LogExceptionThrown(char* exceptionTypeName, char* exceptionMessage, IntPtr faultingIP, long hresult);
+
+        [LibraryImport(RuntimeLibrary)]
+        [UnmanagedCallConv(CallConvs = new Type[] { typeof(CallConvCdecl) })]
+        internal static partial void NativeRuntimeEventSource_LogWaitHandleWaitStart(
+            byte WaitSource,
+            IntPtr AssociatedObjectID,
+            ushort ClrInstanceID);
+
+        [LibraryImport(RuntimeLibrary)]
+        [UnmanagedCallConv(CallConvs = new Type[] { typeof(CallConvCdecl) })]
+        internal static partial void NativeRuntimeEventSource_LogWaitHandleWaitStop(ushort ClrInstanceID);
 #endif // FEATURE_PERFTRACING
 
         //
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Condition.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Condition.cs
index 66636d7f78260..70843a3b940fc 100644
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Condition.cs
+++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Condition.cs
@@ -3,8 +3,8 @@
 
 #pragma warning disable 0420 //passing volatile fields by ref
 
-
 using System.Diagnostics;
+using System.Diagnostics.Tracing;
 
 namespace System.Threading
 {
@@ -97,7 +97,7 @@ public Condition(Lock @lock)
 
         public bool Wait(TimeSpan timeout) => Wait(WaitHandle.ToTimeoutMilliseconds(timeout));
 
-        public unsafe bool Wait(int millisecondsTimeout)
+        public unsafe bool Wait(int millisecondsTimeout, object? associatedObjectForMonitorWait = null)
         {
             ArgumentOutOfRangeException.ThrowIfLessThan(millisecondsTimeout, -1);
 
@@ -111,7 +111,13 @@ public unsafe bool Wait(int millisecondsTimeout)
             bool success = false;
             try
             {
-                success = waiter.ev.WaitOne(millisecondsTimeout);
+                success =
+                    waiter.ev.WaitOneNoCheck(
+                        millisecondsTimeout,
+                        associatedObjectForMonitorWait,
+                        associatedObjectForMonitorWait != null
+                            ? NativeRuntimeEventSource.WaitHandleWaitSourceMap.MonitorWait
+                            : NativeRuntimeEventSource.WaitHandleWaitSourceMap.Unknown);
             }
             finally
             {
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Monitor.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Monitor.NativeAot.cs
index 66016246231fe..c9b270b716dd4 100644
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Monitor.NativeAot.cs
+++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Monitor.NativeAot.cs
@@ -146,7 +146,7 @@ public static bool IsEntered(object obj)
         [UnsupportedOSPlatform("browser")]
         public static bool Wait(object obj, int millisecondsTimeout)
         {
-            return GetCondition(obj).Wait(millisecondsTimeout);
+            return GetCondition(obj).Wait(millisecondsTimeout, obj);
         }
 
         public static void Pulse(object obj)
diff --git a/src/coreclr/scripts/genRuntimeEventSources.py b/src/coreclr/scripts/genRuntimeEventSources.py
index f47a30f284519..5fcfbc0476f11 100644
--- a/src/coreclr/scripts/genRuntimeEventSources.py
+++ b/src/coreclr/scripts/genRuntimeEventSources.py
@@ -85,11 +85,9 @@ def getManifestsToGenerate(runtimeFlavor):
 
 def generateEvent(eventNode, providerNode, outputFile, stringTable):
 
-    # ThreadPool and Contention events are defined manually in NativeRuntimeEventSource.Threading.cs
+    # Some threading events are defined manually in NativeRuntimeEventSource.Threading.cs
     symbol = eventNode.getAttribute("symbol")
-    if "ThreadPool" in symbol:
-        return
-    if "Contention" in symbol:
+    if any(s in symbol for s in ["ThreadPool", "Contention", "WaitHandle"]):
         return
 
     evtLevel = eventNode.getAttribute("level")[4:]
diff --git a/src/coreclr/vm/ClrEtwAll.man b/src/coreclr/vm/ClrEtwAll.man
index e04d5b49b1409..265d7a07726cf 100644
--- a/src/coreclr/vm/ClrEtwAll.man
+++ b/src/coreclr/vm/ClrEtwAll.man
@@ -89,6 +89,8 @@
                              message="$(string.RuntimePublisher.JitInstrumentationDataKeywordMessage)" symbol="CLR_JITINSTRUMENTEDDATA_KEYWORD" />
                     <keyword name="ProfilerKeyword" mask="0x20000000000"
                              message="$(string.RuntimePublisher.ProfilerKeywordMessage)" symbol="CLR_PROFILER_KEYWORD" />
+                    <keyword name="WaitHandleKeyword" mask="0x40000000000"
+                             message="$(string.RuntimePublisher.WaitHandleKeywordMessage)" symbol="CLR_WAITHANDLE_KEYWORD"/>
                 </keywords>
                 <!--Tasks-->
                 <tasks>
@@ -453,7 +455,13 @@
                         <opcodes>
                         </opcodes>
                     </task>
-                <!--Next available ID is 39-->
+                    <task name="WaitHandleWait" symbol="CLR_WAITHANDLEWAIT_TASK"
+                          value="39" eventGUID="{E90049D8-8AB8-4799-B072-EEF41265BCA4}"
+                          message="$(string.RuntimePublisher.WaitHandleWaitTaskMessage)">
+                        <opcodes>
+                        </opcodes>
+                    </task>
+                <!--Next available ID is 40-->
                 </tasks>
                 <!--Maps-->
                 <maps>
@@ -504,6 +512,10 @@
                         <map value="0x0" message="$(string.RuntimePublisher.Contention.ManagedMapMessage)"/>
                         <map value="0x1" message="$(string.RuntimePublisher.Contention.NativeMapMessage)"/>
                     </valueMap>
+                    <valueMap name="WaitHandleWaitSourceMap">
+                        <map value="0x0" message="$(string.RuntimePublisher.WaitHandleWaitSource.UnknownMapMessage)"/>
+                        <map value="0x1" message="$(string.RuntimePublisher.WaitHandleWaitSource.MonitorWaitMapMessage)"/>
+                    </valueMap>
                     <valueMap name="TailCallTypeMap">
                         <map value="0x0" message="$(string.RuntimePublisher.TailCallType.OptimizedMapMessage)"/>
                         <map value="0x1" message="$(string.RuntimePublisher.TailCallType.RecursiveMapMessage)"/>
@@ -1775,6 +1787,30 @@
                         </UserData>
                     </template>
 
+                    <template tid="WaitHandleWaitStart">
+                        <data name="WaitSource" inType="win:UInt8" map="WaitHandleWaitSourceMap" />
+                        <data name="AssociatedObjectID" inType="win:Pointer" />
+                        <data name="ClrInstanceID" inType="win:UInt16" />
+
+                        <UserData>
+                            <WaitHandleWaitStart xmlns="myNs">
+                                <WaitSource> %1 </WaitSource>
+                                <AssociatedObjectID> %2 </AssociatedObjectID>
+                                <ClrInstanceID> %3 </ClrInstanceID>
+                            </WaitHandleWaitStart>
+                        </UserData>
+                    </template>
+
+                    <template tid="WaitHandleWaitStop">
+                        <data name="ClrInstanceID" inType="win:UInt16" />
+
+                        <UserData>
+                            <WaitHandleWaitStop xmlns="myNs">
+                                <ClrInstanceID> %1 </ClrInstanceID>
+                            </WaitHandleWaitStop>
+                        </UserData>
+                    </template>
+
                     <template tid="DomainModuleLoadUnload">
                         <data name="ModuleID" inType="win:UInt64" outType="win:HexInt64" />
                         <data name="AssemblyID" inType="win:UInt64" outType="win:HexInt64" />
@@ -3696,7 +3732,6 @@
                            task="Contention"
                            symbol="ContentionLockCreated" message="$(string.RuntimePublisher.ContentionLockCreatedEventMessage)"/>
 
-
                     <!-- CLR Stack events -->
                     <event value="82" version="0" level="win:LogAlways"  template="ClrStackWalk"
                            keywords ="StackKeyword"  opcode="CLRStackWalk"
@@ -4211,6 +4246,17 @@
                            keywords ="PerfTrackKeyword" opcode="ExecutionCheckpoint" task="ExecutionCheckpoint" symbol="ExecutionCheckpoint"
                            message="$(string.RuntimePublisher.ExecutionCheckpointEventMessage)"/>
 
+                    <!-- Wait Handle events -->
+                    <event value="301" version="0" level="win:Verbose" template="WaitHandleWaitStart"
+                           keywords="WaitHandleKeyword" opcode="win:Start"
+                           task="WaitHandleWait"
+                           symbol="WaitHandleWaitStart" message="$(string.RuntimePublisher.WaitHandleWaitStartEventMessage)"/>
+
+                    <event value="302" version="0" level="win:Verbose" template="WaitHandleWaitStop"
+                           keywords="WaitHandleKeyword" opcode="win:Stop"
+                           task="WaitHandleWait"
+                           symbol="WaitHandleWaitStop" message="$(string.RuntimePublisher.WaitHandleWaitStopEventMessage)"/>
+
                 </events>
             </provider>
 
@@ -8568,6 +8614,8 @@
                 <string id="RuntimePublisher.TieredCompilationBackgroundJitStartEventMessage" value="ClrInstanceID=%1;%nPendingMethodCount=%2" />
                 <string id="RuntimePublisher.TieredCompilationBackgroundJitStopEventMessage" value="ClrInstanceID=%1;%nPendingMethodCount=%2;%nJittedMethodCount=%3" />
                 <string id="RuntimePublisher.ExecutionCheckpointEventMessage" value="ClrInstanceID=%1;Checkpoint=%2;Timestamp=%3"/>
+                <string id="RuntimePublisher.WaitHandleWaitStartEventMessage" value="WaitSource=%1;%nAssociatedObjectID=%2;%nClrInstanceID=%3"/>
+                <string id="RuntimePublisher.WaitHandleWaitStopEventMessage" value="ClrInstanceID=%1"/>
 
                 <string id="RundownPublisher.MethodDCStartEventMessage" value="MethodID=%1;%nModuleID=%2;%nMethodStartAddress=%3;%nMethodSize=%4;%nMethodToken=%5;%nMethodFlags=%6" />
                 <string id="RundownPublisher.MethodDCStart_V1EventMessage" value="MethodID=%1;%nModuleID=%2;%nMethodStartAddress=%3;%nMethodSize=%4;%nMethodToken=%5;%nMethodFlags=%6;%nClrInstanceID=%7" />
@@ -8742,6 +8790,7 @@
                 <string id="RuntimePublisher.ExecutionCheckpointTaskMessage" value="ExecutionCheckpoint" />
                 <string id="RuntimePublisher.ProfilerTaskMessage" value="Profiler" />
                 <string id="RuntimePublisher.YieldProcessorMeasurementTaskMessage" value="YieldProcessorMeasurement" />
+                <string id="RuntimePublisher.WaitHandleWaitTaskMessage" value="WaitHandleWait" />
 
                 <string id="RundownPublisher.GCTaskMessage" value="GC" />
                 <string id="RundownPublisher.EEStartupTaskMessage" value="Runtime" />
@@ -8934,6 +8983,8 @@
                 <string id="RuntimePublisher.ResolutionAttempted.IncompatibleVersion" value="IncompatibleVersion" />
                 <string id="RuntimePublisher.ResolutionAttempted.Failure" value="Failure" />
                 <string id="RuntimePublisher.ResolutionAttempted.Exception" value="Exception" />
+                <string id="RuntimePublisher.WaitHandleWaitSource.UnknownMapMessage" value="Unknown" />
+                <string id="RuntimePublisher.WaitHandleWaitSource.MonitorWaitMapMessage" value="MonitorWait" />
 
                 <string id="RundownPublisher.AppDomain.ExecutableMapMessage" value="Executable" />
                 <string id="RundownPublisher.AppDomain.SharedMapMessage" value="Shared" />
@@ -9103,6 +9154,7 @@
                 <string id="RundownPublisher.PerfTrackRundownKeywordMessage" value="PerfTrack" />
                 <string id="RundownPublisher.StackKeywordMessage" value="Stack" />
                 <string id="RundownPublisher.CompilationKeywordMessage" value="Compilation" />
+                <string id="RuntimePublisher.WaitHandleKeywordMessage" value="WaitHandle" />
 
                 <string id="PrivatePublisher.GCPrivateKeywordMessage" value="GC" />
                 <string id="PrivatePublisher.StartupKeywordMessage" value="Startup" />
diff --git a/src/coreclr/vm/ClrEtwAllMeta.lst b/src/coreclr/vm/ClrEtwAllMeta.lst
index a4ea6e8a4cdb0..3e9ce9804d48f 100644
--- a/src/coreclr/vm/ClrEtwAllMeta.lst
+++ b/src/coreclr/vm/ClrEtwAllMeta.lst
@@ -192,6 +192,13 @@ nostack:Contention:::ContentionStop_V1
 nomac:Contention:::ContentionStop_V1
 nomac:Contention:::ContentionLockCreated
 
+###################
+# WaitHandle events
+###################
+nomac:WaitHandle:::WaitHandleWaitStart
+nostack:WaitHandle:::WaitHandleWaitStop
+nomac:WaitHandle:::WaitHandleWaitStop
+
 ##################
 # StackWalk events
 ##################
diff --git a/src/coreclr/vm/syncblk.cpp b/src/coreclr/vm/syncblk.cpp
index 13ab5daf4aa83..ed7aab14e05e0 100644
--- a/src/coreclr/vm/syncblk.cpp
+++ b/src/coreclr/vm/syncblk.cpp
@@ -2850,6 +2850,7 @@ BOOL SyncBlock::Wait(INT32 timeOut)
     PendingSync   syncState(walk);
 
     OBJECTREF     obj = m_Monitor.GetOwningObject();
+    syncState.m_Object = OBJECTREFToObject(obj);
 
     m_Monitor.IncrementTransientPrecious();
 
diff --git a/src/coreclr/vm/threads.cpp b/src/coreclr/vm/threads.cpp
index 909d85e91c954..507a8eb0ea2ca 100644
--- a/src/coreclr/vm/threads.cpp
+++ b/src/coreclr/vm/threads.cpp
@@ -3169,6 +3169,7 @@ DWORD Thread::DoAppropriateWait(int countHandles, HANDLE *handles, BOOL waitAll,
         BOOL waitAll;
         DWORD millis;
         WaitMode mode;
+        void *associatedObjectForMonitorWait;
         DWORD dwRet;
     } param;
     param.pThis = this;
@@ -3177,10 +3178,11 @@ DWORD Thread::DoAppropriateWait(int countHandles, HANDLE *handles, BOOL waitAll,
     param.waitAll = waitAll;
     param.millis = millis;
     param.mode = mode;
+    param.associatedObjectForMonitorWait = syncState != NULL ? syncState->m_Object : NULL;
     param.dwRet = (DWORD) -1;
 
     EE_TRY_FOR_FINALLY(Param *, pParam, &param) {
-        pParam->dwRet = pParam->pThis->DoAppropriateWaitWorker(pParam->countHandles, pParam->handles, pParam->waitAll, pParam->millis, pParam->mode);
+        pParam->dwRet = pParam->pThis->DoAppropriateWaitWorker(pParam->countHandles, pParam->handles, pParam->waitAll, pParam->millis, pParam->mode, pParam->associatedObjectForMonitorWait);
     }
     EE_FINALLY {
         if (syncState) {
@@ -3383,7 +3385,7 @@ void UnMarkOSAlertableWait()
 // style of Wait.
 //--------------------------------------------------------------------
 DWORD Thread::DoAppropriateWaitWorker(int countHandles, HANDLE *handles, BOOL waitAll,
-                                      DWORD millis, WaitMode mode)
+                                      DWORD millis, WaitMode mode, void *associatedObjectForMonitorWait)
 {
     CONTRACTL {
         THROWS;
@@ -3456,6 +3458,47 @@ DWORD Thread::DoAppropriateWaitWorker(int countHandles, HANDLE *handles, BOOL wa
 
     ThreadStateHolder tsh(alertable, TS_Interruptible | TS_Interrupted);
 
+    bool sendWaitEvents =
+        millis != 0 &&
+        (mode & WaitMode_Alertable) != 0 &&
+        ETW_TRACING_CATEGORY_ENABLED(
+            MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_DOTNET_Context,
+            TRACE_LEVEL_VERBOSE,
+            CLR_WAITHANDLE_KEYWORD);
+
+    // Monitor.Wait is typically a blocking wait. For other waits, when sending the wait events try a nonblocking wait first
+    // such that the events sent are more likely to represent blocking waits.
+    bool tryNonblockingWaitFirst = sendWaitEvents && associatedObjectForMonitorWait == NULL;
+    if (tryNonblockingWaitFirst)
+    {
+        ret = DoAppropriateAptStateWait(countHandles, handles, waitAll, 0 /* timeout */, mode);
+        if (ret == WAIT_TIMEOUT)
+        {
+            // Do a full wait and send the wait events
+            tryNonblockingWaitFirst = false;
+        }
+        else if (ret != WAIT_IO_COMPLETION && ret != WAIT_FAILED)
+        {
+            // The nonblocking wait was successful, don't send the wait events
+            sendWaitEvents = false;
+        }
+    }
+
+    if (sendWaitEvents)
+    {
+        if (associatedObjectForMonitorWait != NULL)
+        {
+            FireEtwWaitHandleWaitStart(
+                ETW::WaitHandleLog::WaitHandleStructs::MonitorWait,
+                associatedObjectForMonitorWait,
+                GetClrInstanceId());
+        }
+        else
+        {
+            FireEtwWaitHandleWaitStart(ETW::WaitHandleLog::WaitHandleStructs::Unknown, NULL, GetClrInstanceId());
+        }
+    }
+
     ULONGLONG dwStart = 0, dwEnd;
 retry:
     if (millis != INFINITE)
@@ -3463,7 +3506,15 @@ DWORD Thread::DoAppropriateWaitWorker(int countHandles, HANDLE *handles, BOOL wa
         dwStart = CLRGetTickCount64();
     }
 
-    ret = DoAppropriateAptStateWait(countHandles, handles, waitAll, millis, mode);
+    if (tryNonblockingWaitFirst)
+    {
+        // We have a final wait result from the nonblocking wait above
+        tryNonblockingWaitFirst = false;
+    }
+    else
+    {
+        ret = DoAppropriateAptStateWait(countHandles, handles, waitAll, millis, mode);
+    }
 
     if (ret == WAIT_IO_COMPLETION)
     {
@@ -3479,7 +3530,7 @@ DWORD Thread::DoAppropriateWaitWorker(int countHandles, HANDLE *handles, BOOL wa
         if (millis != INFINITE)
         {
             dwEnd = CLRGetTickCount64();
-            if (dwEnd >= dwStart + millis)
+            if (dwEnd - dwStart >= millis)
             {
                 ret = WAIT_TIMEOUT;
                 goto WaitCompleted;
@@ -3564,7 +3615,7 @@ DWORD Thread::DoAppropriateWaitWorker(int countHandles, HANDLE *handles, BOOL wa
             dwEnd = CLRGetTickCount64();
             if (millis != INFINITE)
             {
-                if (dwEnd >= dwStart + millis)
+                if (dwEnd - dwStart >= millis)
                 {
                     ret = WAIT_TIMEOUT;
                     goto WaitCompleted;
@@ -3610,6 +3661,11 @@ DWORD Thread::DoAppropriateWaitWorker(int countHandles, HANDLE *handles, BOOL wa
 
     _ASSERTE((ret != WAIT_TIMEOUT) || (millis != INFINITE));
 
+    if (sendWaitEvents)
+    {
+        FireEtwWaitHandleWaitStop(GetClrInstanceId());
+    }
+
     return ret;
 }
 
diff --git a/src/coreclr/vm/threads.h b/src/coreclr/vm/threads.h
index 29270fd1fd1dd..bfb154b0e539d 100644
--- a/src/coreclr/vm/threads.h
+++ b/src/coreclr/vm/threads.h
@@ -2687,7 +2687,7 @@ class Thread
 private:
     void           DoAppropriateWaitWorkerAlertableHelper(WaitMode mode);
     DWORD          DoAppropriateWaitWorker(int countHandles, HANDLE *handles, BOOL waitAll,
-                                           DWORD millis, WaitMode mode);
+                                           DWORD millis, WaitMode mode, void *associatedObjectForMonitorWait);
     DWORD          DoAppropriateWaitWorker(AppropriateWaitFunc func, void *args,
                                            DWORD millis, WaitMode mode);
     DWORD          DoSignalAndWaitWorker(HANDLE* pHandles, DWORD millis,BOOL alertable);
@@ -4979,6 +4979,7 @@ inline void Thread::DecrementTraceCallCount()
 // state to be correct.  So we carry it around in case we need to restore it.
 struct PendingSync
 {
+    void*           m_Object;
     LONG            m_EnterCount;
     WaitEventLink  *m_WaitEventLink;
 #ifdef _DEBUG
diff --git a/src/libraries/Common/tests/System/Diagnostics/Tracing/TestEventListener.cs b/src/libraries/Common/tests/System/Diagnostics/Tracing/TestEventListener.cs
index 576a862575b2b..2e53b8aff7fa7 100644
--- a/src/libraries/Common/tests/System/Diagnostics/Tracing/TestEventListener.cs
+++ b/src/libraries/Common/tests/System/Diagnostics/Tracing/TestEventListener.cs
@@ -23,15 +23,20 @@ private class Settings
         private Action<EventWrittenEventArgs> _eventWritten;
         private readonly List<EventSource> _eventSourceList = new List<EventSource>();
 
-        public TestEventListener(string targetSourceName, EventLevel level, double? eventCounterInterval = null)
+        public TestEventListener(double? eventCounterInterval = null)
         {
             _eventCounterInterval = eventCounterInterval;
+        }
+
+        public TestEventListener(string targetSourceName, EventLevel level, double? eventCounterInterval = null)
+            : this(eventCounterInterval)
+        {
             AddSource(targetSourceName, level);
         }
 
         public TestEventListener(Guid targetSourceGuid, EventLevel level, double? eventCounterInterval = null)
+            : this(eventCounterInterval)
         {
-            _eventCounterInterval = eventCounterInterval;
             AddSource(targetSourceGuid, level);
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs
index a97f2ef62c9fe..b6f612532f4fe 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs
@@ -32,6 +32,8 @@ private static partial class Messages
             public const string IOEnqueue = "NativeOverlapped={0};\nOverlapped={1};\nMultiDequeues={2};\nClrInstanceID={3}";
             public const string IO = "NativeOverlapped={0};\nOverlapped={1};\nClrInstanceID={2}";
             public const string WorkingThreadCount = "Count={0};\nClrInstanceID={1}";
+            public const string WaitHandleWaitStart = "WaitSource={0};\nAssociatedObjectID={1};\nClrInstanceID={2}";
+            public const string WaitHandleWaitStop = "ClrInstanceID={0}";
         }
 
         // The task definitions for the ETW manifest
@@ -43,6 +45,7 @@ private static partial class Messages
             public const EventTask ThreadPool = (EventTask)23;
             public const EventTask ThreadPoolWorkingThreadCount = (EventTask)22;
             public const EventTask ThreadPoolMinMaxThreads = (EventTask)38;
+            public const EventTask WaitHandleWait = (EventTask)39;
         }
 
         public static partial class Opcodes // this name and visibility is important for EventSource
@@ -76,6 +79,12 @@ public enum ThreadAdjustmentReasonMap : uint
             CooperativeBlocking,
         }
 
+        public enum WaitHandleWaitSourceMap : byte
+        {
+            Unknown,
+            MonitorWait,
+        }
+
         [Event(90, Level = EventLevel.Informational, Message = Messages.ContentionLockCreated, Task = Tasks.Contention, Opcode = EventOpcode.Info, Version = 0, Keywords = Keywords.ContentionKeyword)]
         private void ContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort ClrInstanceID = DefaultClrInstanceId)
         {
@@ -320,5 +329,29 @@ public unsafe void ThreadPoolMinMaxThreads(
                 LogThreadPoolMinMaxThreads(MinWorkerThreads, MaxWorkerThreads, MinIOCompletionThreads, MaxIOCompletionThreads, ClrInstanceID);
             }
         }
+
+        [Event(301, Level = EventLevel.Verbose, Message = Messages.WaitHandleWaitStart, Task = Tasks.WaitHandleWait, Opcode = EventOpcode.Start, Version = 0, Keywords = Keywords.WaitHandleKeyword)]
+        private void WaitHandleWaitStart(
+            WaitHandleWaitSourceMap WaitSource,
+            nint AssociatedObjectID,
+            ushort ClrInstanceID = DefaultClrInstanceId)
+        {
+            Debug.Assert(IsEnabled(EventLevel.Verbose, Keywords.WaitHandleKeyword));
+            LogWaitHandleWaitStart(WaitSource, AssociatedObjectID, ClrInstanceID);
+        }
+
+        [NonEvent]
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void WaitHandleWaitStart(
+            WaitHandleWaitSourceMap waitSource = WaitHandleWaitSourceMap.Unknown,
+            object? associatedObject = null) =>
+            WaitHandleWaitStart(waitSource, *(nint*)Unsafe.AsPointer(ref associatedObject));
+
+        [Event(302, Level = EventLevel.Verbose, Message = Messages.WaitHandleWaitStop, Task = Tasks.WaitHandleWait, Opcode = EventOpcode.Stop, Version = 0, Keywords = Keywords.WaitHandleKeyword)]
+        public void WaitHandleWaitStop(ushort ClrInstanceID = DefaultClrInstanceId)
+        {
+            Debug.Assert(IsEnabled(EventLevel.Verbose, Keywords.WaitHandleKeyword));
+            LogWaitHandleWaitStop(ClrInstanceID);
+        }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.cs
index 59d49bf7892ad..2dff7526e35d8 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.cs
@@ -17,6 +17,7 @@ public static partial class Keywords
             public const EventKeywords ContentionKeyword = (EventKeywords)0x4000;
             public const EventKeywords ThreadingKeyword = (EventKeywords)0x10000;
             public const EventKeywords ThreadTransferKeyword = (EventKeywords)0x80000000;
+            public const EventKeywords WaitHandleKeyword = (EventKeywords)0x40000000000;
         }
 
         private static partial class Messages
@@ -32,6 +33,8 @@ private static partial class Messages
             public const string IOEnqueue = "NativeOverlapped={0};\nOverlapped={1};\nMultiDequeues={2};\nClrInstanceID={3}";
             public const string IO = "NativeOverlapped={0};\nOverlapped={1};\nClrInstanceID={2}";
             public const string WorkingThreadCount = "Count={0};\nClrInstanceID={1}";
+            public const string WaitHandleWaitStart = "WaitSource={0};\nAssociatedObjectID={1};\nClrInstanceID={2}";
+            public const string WaitHandleWaitStop = "ClrInstanceID={0}";
         }
 
         // The task definitions for the ETW manifest
@@ -43,6 +46,7 @@ private static partial class Messages
             public const EventTask ThreadPool = (EventTask)23;
             public const EventTask ThreadPoolWorkingThreadCount = (EventTask)22;
             public const EventTask ThreadPoolMinMaxThreads = (EventTask)38;
+            public const EventTask WaitHandleWait = (EventTask)39;
         }
 
         public static partial class Opcodes // this name and visibility is important for EventSource
@@ -76,6 +80,12 @@ public enum ThreadAdjustmentReasonMap : uint
             CooperativeBlocking,
         }
 
+        public enum WaitHandleWaitSourceMap : byte
+        {
+            Unknown,
+            MonitorWait,
+        }
+
         [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
         [Event(90, Level = EventLevel.Informational, Message = Messages.ContentionLockCreated, Task = Tasks.Contention, Opcode = EventOpcode.Info, Version = 0, Keywords = Keywords.ContentionKeyword)]
         private unsafe void ContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort ClrInstanceID = DefaultClrInstanceId)
@@ -504,5 +514,47 @@ public unsafe void ThreadPoolMinMaxThreads(
             data[4].Reserved = 0;
             WriteEventCore(59, 5, data);
         }
+
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
+        [Event(301, Level = EventLevel.Verbose, Message = Messages.WaitHandleWaitStart, Task = Tasks.WaitHandleWait, Opcode = EventOpcode.Start, Version = 0, Keywords = Keywords.WaitHandleKeyword)]
+        private unsafe void WaitHandleWaitStart(
+            WaitHandleWaitSourceMap WaitSource,
+            nint AssociatedObjectID,
+            ushort ClrInstanceID = DefaultClrInstanceId)
+        {
+            Debug.Assert(IsEnabled(EventLevel.Verbose, Keywords.WaitHandleKeyword));
+
+            EventData* data = stackalloc EventData[3];
+            data[0].DataPointer = (nint)(&WaitSource);
+            data[0].Size = sizeof(WaitHandleWaitSourceMap);
+            data[0].Reserved = 0;
+            data[1].DataPointer = (nint)(&AssociatedObjectID);
+            data[1].Size = nint.Size;
+            data[1].Reserved = 0;
+            data[2].DataPointer = (nint)(&ClrInstanceID);
+            data[2].Size = sizeof(ushort);
+            data[2].Reserved = 0;
+            WriteEventCore(301, 3, data);
+        }
+
+        [NonEvent]
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void WaitHandleWaitStart(
+            WaitHandleWaitSourceMap waitSource = WaitHandleWaitSourceMap.Unknown,
+            object? associatedObject = null) =>
+            WaitHandleWaitStart(waitSource, *(nint*)Unsafe.AsPointer(ref associatedObject));
+
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
+        [Event(302, Level = EventLevel.Verbose, Message = Messages.WaitHandleWaitStop, Task = Tasks.WaitHandleWait, Opcode = EventOpcode.Stop, Version = 0, Keywords = Keywords.WaitHandleKeyword)]
+        public unsafe void WaitHandleWaitStop(ushort ClrInstanceID = DefaultClrInstanceId)
+        {
+            Debug.Assert(IsEnabled(EventLevel.Verbose, Keywords.WaitHandleKeyword));
+
+            EventData* data = stackalloc EventData[1];
+            data[0].DataPointer = (nint)(&ClrInstanceID);
+            data[0].Size = sizeof(ushort);
+            data[0].Reserved = 0;
+            WriteEventCore(302, 1, data);
+        }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Unix.cs
index 8a5346fa38632..3ba1cb132e272 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Unix.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Unix.cs
@@ -10,7 +10,7 @@ public abstract partial class WaitHandle
         private static int WaitOneCore(IntPtr handle, int millisecondsTimeout) =>
             WaitSubsystem.Wait(handle, millisecondsTimeout, true);
 
-        internal static int WaitMultipleIgnoringSyncContext(Span<IntPtr> handles, bool waitAll, int millisecondsTimeout) =>
+        private static int WaitMultipleIgnoringSyncContextCore(Span<IntPtr> handles, bool waitAll, int millisecondsTimeout) =>
             WaitSubsystem.Wait(handles, waitAll, millisecondsTimeout);
 
         private static int SignalAndWaitCore(IntPtr handleToSignal, IntPtr handleToWaitOn, int millisecondsTimeout) =>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs
index 18753773a309f..bae0a8f3a23c5 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs
@@ -10,7 +10,7 @@ namespace System.Threading
 {
     public abstract partial class WaitHandle
     {
-        internal static unsafe int WaitMultipleIgnoringSyncContext(Span<IntPtr> handles, bool waitAll, int millisecondsTimeout)
+        private static unsafe int WaitMultipleIgnoringSyncContextCore(Span<IntPtr> handles, bool waitAll, int millisecondsTimeout)
         {
             fixed (IntPtr* pHandles = &MemoryMarshal.GetReference(handles))
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.cs
index 85a236cdcc196..7d78f3aea97cb 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.cs
@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.Tracing;
 using Microsoft.Win32.SafeHandles;
 
 namespace System.Threading
@@ -35,6 +36,7 @@ public abstract partial class WaitHandle : MarshalByRefObject, IDisposable
         internal const int WaitAbandoned = 0x80;
 
         public const int WaitTimeout = 0x102;
+        internal const int WaitFailed = unchecked((int)0xffffffff);
 
         protected WaitHandle()
         {
@@ -102,7 +104,10 @@ public virtual bool WaitOne(int millisecondsTimeout)
             return WaitOneNoCheck(millisecondsTimeout);
         }
 
-        private bool WaitOneNoCheck(int millisecondsTimeout)
+        internal bool WaitOneNoCheck(
+            int millisecondsTimeout,
+            object? associatedObject = null,
+            NativeRuntimeEventSource.WaitHandleWaitSourceMap waitSource = NativeRuntimeEventSource.WaitHandleWaitSourceMap.Unknown)
         {
             Debug.Assert(millisecondsTimeout >= -1);
 
@@ -114,10 +119,9 @@ private bool WaitOneNoCheck(int millisecondsTimeout)
             bool success = false;
             try
             {
-                int waitResult;
-
                 waitHandle.DangerousAddRef(ref success);
 
+                int waitResult = WaitFailed;
                 SynchronizationContext? context = SynchronizationContext.Current;
                 if (context != null && context.IsWaitNotificationRequired())
                 {
@@ -125,7 +129,51 @@ private bool WaitOneNoCheck(int millisecondsTimeout)
                 }
                 else
                 {
-                    waitResult = WaitOneCore(waitHandle.DangerousGetHandle(), millisecondsTimeout);
+#if !CORECLR // CoreCLR sends the wait events from the native side
+                    bool sendWaitEvents =
+                        millisecondsTimeout != 0 &&
+                        NativeRuntimeEventSource.Log.IsEnabled(
+                            EventLevel.Verbose,
+                            NativeRuntimeEventSource.Keywords.WaitHandleKeyword);
+
+                    // Monitor.Wait is typically a blocking wait. For other waits, when sending the wait events try a
+                    // nonblocking wait first such that the events sent are more likely to represent blocking waits.
+                    bool tryNonblockingWaitFirst =
+                        sendWaitEvents &&
+                        waitSource != NativeRuntimeEventSource.WaitHandleWaitSourceMap.MonitorWait;
+                    if (tryNonblockingWaitFirst)
+                    {
+                        waitResult = WaitOneCore(waitHandle.DangerousGetHandle(), millisecondsTimeout: 0);
+                        if (waitResult == WaitTimeout)
+                        {
+                            // Do a full wait and send the wait events
+                            tryNonblockingWaitFirst = false;
+                        }
+                        else
+                        {
+                            // The nonblocking wait was successful, don't send the wait events
+                            sendWaitEvents = false;
+                        }
+                    }
+
+                    if (sendWaitEvents)
+                    {
+                        NativeRuntimeEventSource.Log.WaitHandleWaitStart(waitSource, associatedObject ?? this);
+                    }
+
+                    // When tryNonblockingWaitFirst is true, we have a final wait result from the nonblocking wait above
+                    if (!tryNonblockingWaitFirst)
+#endif
+                    {
+                        waitResult = WaitOneCore(waitHandle.DangerousGetHandle(), millisecondsTimeout);
+                    }
+
+#if !CORECLR // CoreCLR sends the wait events from the native side
+                    if (sendWaitEvents)
+                    {
+                        NativeRuntimeEventSource.Log.WaitHandleWaitStop();
+                    }
+#endif
                 }
 
                 if (waitResult == WaitAbandoned)
@@ -338,6 +386,57 @@ private static int WaitAnyMultiple(ReadOnlySpan<SafeWaitHandle> safeWaitHandles,
             return waitResult;
         }
 
+        internal static int WaitMultipleIgnoringSyncContext(Span<IntPtr> handles, bool waitAll, int millisecondsTimeout)
+        {
+            int waitResult = WaitFailed;
+
+#if !CORECLR // CoreCLR sends the wait events from the native side
+            bool sendWaitEvents =
+                millisecondsTimeout != 0 &&
+                NativeRuntimeEventSource.Log.IsEnabled(
+                    EventLevel.Verbose,
+                    NativeRuntimeEventSource.Keywords.WaitHandleKeyword);
+
+            // When sending the wait events try a nonblocking wait first such that the events sent are more likely to
+            // represent blocking waits
+            bool tryNonblockingWaitFirst = sendWaitEvents;
+            if (tryNonblockingWaitFirst)
+            {
+                waitResult = WaitMultipleIgnoringSyncContextCore(handles, waitAll, millisecondsTimeout: 0);
+                if (waitResult == WaitTimeout)
+                {
+                    // Do a full wait and send the wait events
+                    tryNonblockingWaitFirst = false;
+                }
+                else
+                {
+                    // The nonblocking wait was successful, don't send the wait events
+                    sendWaitEvents = false;
+                }
+            }
+
+            if (sendWaitEvents)
+            {
+                NativeRuntimeEventSource.Log.WaitHandleWaitStart();
+            }
+
+            // When tryNonblockingWaitFirst is true, we have a final wait result from the nonblocking wait above
+            if (!tryNonblockingWaitFirst)
+#endif
+            {
+                waitResult = WaitMultipleIgnoringSyncContextCore(handles, waitAll, millisecondsTimeout);
+            }
+
+#if !CORECLR // CoreCLR sends the wait events from the native side
+            if (sendWaitEvents)
+            {
+                NativeRuntimeEventSource.Log.WaitHandleWaitStop();
+            }
+#endif
+
+            return waitResult;
+        }
+
         private static bool SignalAndWait(WaitHandle toSignal, WaitHandle toWaitOn, int millisecondsTimeout)
         {
             ArgumentNullException.ThrowIfNull(toSignal);
diff --git a/src/libraries/System.Threading/tests/EtwTests.cs b/src/libraries/System.Threading/tests/EtwTests.cs
index 4ff33587a6ca3..e971209f37708 100644
--- a/src/libraries/System.Threading/tests/EtwTests.cs
+++ b/src/libraries/System.Threading/tests/EtwTests.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.Tracing;
 using Microsoft.DotNet.RemoteExecutor;
@@ -35,5 +36,91 @@ public void TestEtw()
                 }
             }).Dispose();
         }
+
+        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        public void WaitHandleWaitEventTest()
+        {
+            RemoteExecutor.Invoke(() =>
+            {
+                const string providerName = "Microsoft-Windows-DotNETRuntime";
+                const EventKeywords waitHandleKeyword = (EventKeywords)0x40000000000;
+                const int waitHandleWaitStartEventId = 301;
+                const int waitHandleWaitStopEventId = 302;
+                const byte waitSourceMonitorWait = 1;
+
+                List<object[]> startPayloads = new();
+                List<object[]> stopPayloads = new();
+                const int waitCount = 10;
+
+                using TestEventListener listener = new();
+                listener.AddSource(providerName, EventLevel.Verbose, waitHandleKeyword);
+
+                ManualResetEventSlim mres = new(false);
+
+                listener.RunWithCallback(eventData =>
+                {
+                    var payload = new object[eventData.Payload!.Count];
+                    eventData.Payload.CopyTo(payload, 0);
+
+                    if (eventData.EventId == waitHandleWaitStartEventId)
+                    {
+                        startPayloads.Add(payload);
+                    }
+                    else if (eventData.EventId == waitHandleWaitStopEventId)
+                    {
+                        stopPayloads.Add(payload);
+                    }
+
+                    if (startPayloads.Count >= waitCount && stopPayloads.Count >= waitCount)
+                    {
+                        mres.Set();
+                    }
+                }, () =>
+                {
+                    object l = new();
+                    lock (l)
+                    {
+                        for (int i = 0; i < waitCount; i += 1)
+                        {
+                            Assert.False(Monitor.Wait(l, millisecondsTimeout: 1));
+                        }
+                    }
+
+                    try { mres.CheckedWait(); }
+                    catch (Exception ex)
+                    {
+                        throw new AggregateException(
+                            $"Not enough WaitHandleWait events were collected ({startPayloads.Count} + {stopPayloads.Count})",
+                            ex);
+                    }
+                });
+
+                // Avoid exact equality because some random thread could be waiting and so sending events.
+                Assert.True(startPayloads.Count >= waitCount, $"Unexpected number of start events ({startPayloads.Count})");
+                int monitorWaitStartPayloads = 0;
+                foreach (object[] payload in startPayloads)
+                {
+                    Assert.Equal(3, payload.Length);
+                    Assert.IsType<byte>(payload[0]);
+                    Assert.IsType<nint>(payload[1]);
+                    Assert.IsType<ushort>(payload[2]);
+
+                    if ((byte)payload[0] == waitSourceMonitorWait)
+                    {
+                        monitorWaitStartPayloads++;
+                        Assert.NotEqual(0, payload[1]);
+                    }
+                }
+
+                Assert.True(monitorWaitStartPayloads >= waitCount, $"Unexpected number of monitor wait start events ({monitorWaitStartPayloads})");
+
+                Assert.True(stopPayloads.Count >= waitCount, $"Unexpected number of stop events ({stopPayloads.Count})");
+                foreach (object[] payload in stopPayloads)
+                {
+                    Assert.Equal(1, payload.Length);
+                    Assert.IsType<ushort>(payload[0]);
+                }
+            }).Dispose();
+        }
     }
 }
diff --git a/src/mono/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Mono.cs
index 20fc2b2c72da8..1ef6372b257c8 100644
--- a/src/mono/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Mono.cs
@@ -97,5 +97,16 @@ private static extern void LogThreadPoolIOPack(
             IntPtr NativeOverlapped,
             IntPtr Overlapped,
             ushort ClrInstanceID);
+
+        [NonEvent]
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private static extern void LogWaitHandleWaitStart(
+            WaitHandleWaitSourceMap WaitSource,
+            IntPtr AssociatedObjectID,
+            ushort ClrInstanceID);
+
+        [NonEvent]
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private static extern void LogWaitHandleWaitStop(ushort ClrInstanceID);
     }
 }
diff --git a/src/mono/System.Private.CoreLib/src/System/Threading/Monitor.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Threading/Monitor.Mono.cs
index 1765124e341d7..3883b11cd3701 100644
--- a/src/mono/System.Private.CoreLib/src/System/Threading/Monitor.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Threading/Monitor.Mono.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.Tracing;
 using System.Runtime.CompilerServices;
 using System.Runtime.Versioning;
 
@@ -121,7 +122,22 @@ private static bool ObjWait(int millisecondsTimeout, object obj)
             if (!ObjectHeader.HasOwner(obj))
                 throw new SynchronizationLockException();
 
-            return Monitor_wait(obj, millisecondsTimeout, true);
+            bool sendWaitEvents =
+                millisecondsTimeout != 0 &&
+                NativeRuntimeEventSource.Log.IsEnabled(EventLevel.Verbose, NativeRuntimeEventSource.Keywords.WaitHandleKeyword);
+            if (sendWaitEvents)
+            {
+                NativeRuntimeEventSource.Log.WaitHandleWaitStart(NativeRuntimeEventSource.WaitHandleWaitSourceMap.MonitorWait, obj);
+            }
+
+            bool result = Monitor_wait(obj, millisecondsTimeout, true);
+
+            if (sendWaitEvents)
+            {
+                NativeRuntimeEventSource.Log.WaitHandleWaitStop();
+            }
+
+            return result;
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
diff --git a/src/mono/mono/component/event_pipe-stub.c b/src/mono/mono/component/event_pipe-stub.c
index a1769b9454af5..a9484c12b336b 100644
--- a/src/mono/mono/component/event_pipe-stub.c
+++ b/src/mono/mono/component/event_pipe-stub.c
@@ -213,6 +213,16 @@ event_pipe_stub_wait_for_session_signal (
 	EventPipeSessionID session_id,
 	uint32_t timeout);
 
+static bool
+event_pipe_stub_write_event_wait_handle_wait_start (
+	uint8_t wait_source,
+	intptr_t associated_object_id,
+	uint16_t clr_instance_id);
+
+static bool
+event_pipe_stub_write_event_wait_handle_wait_stop (
+	uint16_t clr_instance_id);
+
 MonoComponentEventPipe *
 component_event_pipe_stub_init (void);
 
@@ -251,6 +261,8 @@ static MonoComponentEventPipe fn_table = {
 	&event_pipe_stub_write_event_contention_lock_created,
 	&event_pipe_stub_write_event_contention_start,
 	&event_pipe_stub_write_event_contention_stop,
+	&event_pipe_stub_write_event_wait_handle_wait_start,
+	&event_pipe_stub_write_event_wait_handle_wait_stop,
 	&event_pipe_stub_signal_session,
 	&event_pipe_stub_wait_for_session_signal
 };
@@ -554,6 +566,22 @@ event_pipe_stub_wait_for_session_signal (
 	return true;
 }
 
+static bool
+event_pipe_stub_write_event_wait_handle_wait_start (
+	uint8_t wait_source,
+	intptr_t associated_object_id,
+	uint16_t clr_instance_id)
+{
+	return true;
+}
+
+static bool
+event_pipe_stub_write_event_wait_handle_wait_stop (
+	uint16_t clr_instance_id)
+{
+	return true;
+}
+
 MonoComponentEventPipe *
 component_event_pipe_stub_init (void)
 {
diff --git a/src/mono/mono/component/event_pipe.c b/src/mono/mono/component/event_pipe.c
index 1ea641bd37891..097abde8c2ae2 100644
--- a/src/mono/mono/component/event_pipe.c
+++ b/src/mono/mono/component/event_pipe.c
@@ -141,8 +141,10 @@ static MonoComponentEventPipe fn_table = {
 	&ep_rt_write_event_contention_lock_created,
 	&ep_rt_write_event_contention_start,
 	&ep_rt_write_event_contention_stop,
+	&ep_rt_write_event_wait_handle_wait_start,
+	&ep_rt_write_event_wait_handle_wait_stop,
 	&event_pipe_signal_session,
-	&event_pipe_wait_for_session_signal
+	&event_pipe_wait_for_session_signal,
 };
 
 static bool
diff --git a/src/mono/mono/component/event_pipe.h b/src/mono/mono/component/event_pipe.h
index bc1fe532dbd25..5e359aacd8651 100644
--- a/src/mono/mono/component/event_pipe.h
+++ b/src/mono/mono/component/event_pipe.h
@@ -242,6 +242,16 @@ typedef bool
 	uint16_t clr_instance_id,
 	double duration_ns);
 
+typedef bool
+(*event_pipe_component_write_event_wait_handle_wait_start_func)(
+	uint8_t wait_source,
+	intptr_t associated_object_id,
+	uint16_t clr_instance_id);
+
+typedef bool
+(*event_pipe_component_write_event_wait_handle_wait_stop_func)(
+	uint16_t clr_instance_id);
+
 /*
  * MonoComponentEventPipe function table.
  */
@@ -281,6 +291,8 @@ typedef struct _MonoComponentEventPipe {
 	event_pipe_component_write_event_contention_lock_created_func write_event_contention_lock_created;
 	event_pipe_component_write_event_contention_start_func write_event_contention_start;
 	event_pipe_component_write_event_contention_stop_func write_event_contention_stop;
+	event_pipe_component_write_event_wait_handle_wait_start_func write_event_wait_handle_wait_start;
+	event_pipe_component_write_event_wait_handle_wait_stop_func write_event_wait_handle_wait_stop;
 	event_pipe_component_signal_session signal_session;
 	event_pipe_component_wait_for_session_signal wait_for_session_signal;
 } MonoComponentEventPipe;
diff --git a/src/mono/mono/eventpipe/ep-rt-mono-runtime-provider.c b/src/mono/mono/eventpipe/ep-rt-mono-runtime-provider.c
index fd02bd7dbeab5..0b31632fd53b1 100644
--- a/src/mono/mono/eventpipe/ep-rt-mono-runtime-provider.c
+++ b/src/mono/mono/eventpipe/ep-rt-mono-runtime-provider.c
@@ -2785,6 +2785,30 @@ ep_rt_write_event_contention_stop (
 		NULL) == 0 ? true : false;
 }
 
+bool
+ep_rt_write_event_wait_handle_wait_start (
+	uint8_t wait_source,
+	intptr_t associated_object_id,
+	uint16_t clr_instance_id)
+{
+	return FireEtwWaitHandleWaitStart (
+		wait_source,
+		(const void *)associated_object_id,
+		clr_instance_id,
+		NULL,
+		NULL) == 0 ? true : false;
+}
+
+bool
+ep_rt_write_event_wait_handle_wait_stop (
+	uint16_t clr_instance_id)
+{
+	return FireEtwWaitHandleWaitStop (
+		clr_instance_id,
+		NULL,
+		NULL) == 0 ? true : false;
+}
+
 static
 void
 jit_begin_callback (
diff --git a/src/mono/mono/eventpipe/ep-rt-mono.h b/src/mono/mono/eventpipe/ep-rt-mono.h
index 6b741d4390bb9..35a7607681366 100644
--- a/src/mono/mono/eventpipe/ep-rt-mono.h
+++ b/src/mono/mono/eventpipe/ep-rt-mono.h
@@ -1884,6 +1884,16 @@ ep_rt_write_event_contention_stop (
 	uint16_t clr_instance_id,
 	double duration_ns);
 
+bool
+ep_rt_write_event_wait_handle_wait_start (
+	uint8_t wait_source,
+	intptr_t associated_object_id,
+	uint16_t clr_instance_id);
+
+bool
+ep_rt_write_event_wait_handle_wait_stop (
+	uint16_t clr_instance_id);
+
 /*
 * EventPipe provider callbacks.
 */
diff --git a/src/mono/mono/eventpipe/gen-eventing-event-inc.lst b/src/mono/mono/eventpipe/gen-eventing-event-inc.lst
index 8a9f572a1d5c4..de5d7e96f6323 100644
--- a/src/mono/mono/eventpipe/gen-eventing-event-inc.lst
+++ b/src/mono/mono/eventpipe/gen-eventing-event-inc.lst
@@ -59,4 +59,6 @@ ThreadPoolIOPack
 ThreadTerminated
 TypeLoadStart
 TypeLoadStop
+WaitHandleWaitStart
+WaitHandleWaitStop
 Microsoft-DotNETRuntimeMonoProfiler:*
diff --git a/src/mono/mono/metadata/icall-decl.h b/src/mono/mono/metadata/icall-decl.h
index 704092c5a47c1..1f4ad944a3269 100644
--- a/src/mono/mono/metadata/icall-decl.h
+++ b/src/mono/mono/metadata/icall-decl.h
@@ -176,6 +176,8 @@ ICALL_EXPORT void ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_
 ICALL_EXPORT void ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogContentionLockCreated (intptr_t lock_id, intptr_t associated_object_id, uint16_t clr_instance_id);
 ICALL_EXPORT void ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogContentionStart (uint8_t contention_flags, uint16_t clr_instance_id, intptr_t lock_id, intptr_t associated_object_id, uint64_t lock_owner_thread_id);
 ICALL_EXPORT void ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogContentionStop (uint8_t contention_flags, uint16_t clr_instance_id, double duration_ns);
+ICALL_EXPORT void ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogWaitHandleWaitStart (uint8_t wait_source, intptr_t associated_object_id, uint16_t clr_instance_id);
+ICALL_EXPORT void ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogWaitHandleWaitStop (uint16_t clr_instance_id);
 
 ICALL_EXPORT void ves_icall_Mono_RuntimeGPtrArrayHandle_GPtrArrayFree (GPtrArray *ptr_array);
 ICALL_EXPORT void ves_icall_Mono_SafeStringMarshal_GFree (void *c_str);
diff --git a/src/mono/mono/metadata/icall-def.h b/src/mono/mono/metadata/icall-def.h
index 556eb8708c439..e9b42f9470f27 100644
--- a/src/mono/mono/metadata/icall-def.h
+++ b/src/mono/mono/metadata/icall-def.h
@@ -189,6 +189,8 @@ NOHANDLES(ICALL(NATIVE_RUNTIME_EVENT_SOURCE_11, "LogThreadPoolWorkerThreadStart"
 NOHANDLES(ICALL(NATIVE_RUNTIME_EVENT_SOURCE_12, "LogThreadPoolWorkerThreadStop", ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop))
 NOHANDLES(ICALL(NATIVE_RUNTIME_EVENT_SOURCE_13, "LogThreadPoolWorkerThreadWait", ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait))
 NOHANDLES(ICALL(NATIVE_RUNTIME_EVENT_SOURCE_14, "LogThreadPoolWorkingThreadCount", ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount))
+NOHANDLES(ICALL(NATIVE_RUNTIME_EVENT_SOURCE_15, "LogWaitHandleWaitStart", ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogWaitHandleWaitStart))
+NOHANDLES(ICALL(NATIVE_RUNTIME_EVENT_SOURCE_16, "LogWaitHandleWaitStop", ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogWaitHandleWaitStop))
 
 ICALL_TYPE(ENUM, "System.Enum", ENUM_1)
 HANDLES(ENUM_1, "GetEnumValuesAndNames", ves_icall_System_Enum_GetEnumValuesAndNames, void, 3, (MonoQCallTypeHandle, MonoArrayOut, MonoArrayOut))
diff --git a/src/mono/mono/metadata/icall-eventpipe.c b/src/mono/mono/metadata/icall-eventpipe.c
index 46314b32a43f0..9dea29b3f8341 100644
--- a/src/mono/mono/metadata/icall-eventpipe.c
+++ b/src/mono/mono/metadata/icall-eventpipe.c
@@ -469,6 +469,26 @@ ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogContentionStop
 		duration_ns);
 }
 
+void
+ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogWaitHandleWaitStart (
+	uint8_t wait_source,
+	intptr_t associated_object_id,
+	uint16_t clr_instance_id)
+{
+	mono_component_event_pipe ()->write_event_wait_handle_wait_start (
+		wait_source,
+		associated_object_id,
+		clr_instance_id);
+}
+
+void
+ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogWaitHandleWaitStop (
+	uint16_t clr_instance_id)
+{
+	mono_component_event_pipe ()->write_event_wait_handle_wait_stop (
+		clr_instance_id);
+}
+
 #else /* ENABLE_PERFTRACING */
 
 gconstpointer
@@ -778,4 +798,24 @@ ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogContentionStop
 	mono_error_set_pending_exception (error);
 }
 
+void
+ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogWaitHandleWaitStart (
+	uint8_t wait_source,
+	intptr_t associated_object_id,
+	uint16_t clr_instance_id)
+{
+	ERROR_DECL (error);
+	mono_error_set_not_implemented (error, "System.Diagnostics.Tracing.NativeRuntimeEventSource.WaitHandleWaitStart");
+	mono_error_set_pending_exception (error);
+}
+
+void
+ves_icall_System_Diagnostics_Tracing_NativeRuntimeEventSource_LogWaitHandleWaitStop (
+	uint16_t clr_instance_id)
+{
+	ERROR_DECL (error);
+	mono_error_set_not_implemented (error, "System.Diagnostics.Tracing.NativeRuntimeEventSource.WaitHandleWaitStop");
+	mono_error_set_pending_exception (error);
+}
+
 #endif /* ENABLE_PERFTRACING */