Well even if it wasn't the problem its good to know Corn/SiCrane. Its something I will not do, despite not making much sense IMHO.

Yeah, it's kind of weird. I think it kind of makes sense (helping you not assign to temporaries that are about to get nuked can help avoid some bugs), but at the same time, it seems like an unnecessary restriction. I think that's the main reason this question has so many upvotes, but answers don't (that is, the question is a good, interesting question, but the answers (provided by the standard) aren't very satisfactory).

I think the best answer to this question is actually in one of the comments in that question (from sbi):

The reason Stroustrup gives (in [Design and Evolution of C++]) for disallowing the binding of rvalues to non-const references is that, if Alexey's g() would modify the object (which you'd expect from a function taking a non-const reference), it would modify an object that's going to die, so nobody could get at the modified value anyway. He says that this, most likely, is an error.

It seems kinda weird that C++ is trying to hold your hand here (seeing that the rest of the standard doesn't care if you shoot your leg off if you want), but oh well.

The problem isn't throwing the object. The problem is modifying the temporary object, which (by standard C++) is undefined behavior. The problem is binding a non-constant reference to a temporary object and then modifying the object (not throwing the object). In the ThrowException() function, e is a reference to a temporary, and you are modifying it, which is undefined behavior. e should be a const reference, and you should not modify it (feel free to throw it).

Is not the reference valid for the lifetime of the temporary object? I was certain pg.245 of N3337 implies that the temporary object the reference was bound to will exist for the duration of the function, in particular 12.2.5. Am I reading this wrong?