This is just speculation, but it is possible that most of the events appear to get deleted fine due to implementation defined behavior of the runtime's allocator. For example, if every piece of allocated memory is part of a larger block that is predictably aligned, then on delete, the deallocator usually only needs to jump to the beginning of that memory's aligned block and fiddle with some book keeping information. This will work just fine even when technically using the wrong allocator, as long as the code is the same. But as soon as the deallocator notices that it freed the last piece of memory in a block, it might want to clean up the whole block. And to do this, it might need to check some other memory that is unique to that particular allocator (such as a list of memory blocks that the allocator is managing). If this block of memory wasn't actually allocated by the allocator currently doing the deallocation, things get confused really fast.
This might be the kind of thing that is happening when you delete the very last event. All deletes might be wrong, but the debug runtime only notices that fact on the last delete, when it tries to clean up a block.
Also keep in mind that your events are not the only thing being allocated and deallocated across dll boundaries. Every call to events.push_back() is going to use the default list allocator to allocate a linked list node, and every call to events.pop_front() will use that allocator to deallocate the node. But this is almost definitely a stateless static allocator. Since you statically link your event manager to both your exe and dll, the allocator used is going to depend on which module the calls to Queue() and HandleEvents() comes from. Calling Queue() from the dll is going to allocate from the dll, and calling HandleEvents() from the exe is going to deallocate from the exe. No amount of shared_ptr intelligence will protect against this, because this is completely independent of the memory allocated for events. Stateful allocators would solve this (at the cost of a little overhead), but have only been possible since C++11, and I'm not sure what VS2012's support of these is like.
Without stateful allocators, you pretty much need to figure out a way to guarantee that all manipulations to a container happen within a single module. In your case, you might actually try making your event manager library a dll also, instead of a static library. That way, all manipulations to the events list is guaranteed to happen within that dll, regardless of where the call to Queue() and HandleEvents() comes from.