Does notify happen-before wakeup of wait?

Question

Is this program

std::condition_variable cond_var;
std::mutex mtx;
std::atomic<int> value {0};

const auto mem_ord = std::memory_order_seq_cst;

std::thread notify_thread([&]
    {
        {
            //std::unique_lock<std::mutex> lock (mtx);
            value.store (1, mem_ord);
        }
        cond_var.notify ();
    });

{
    std::unique_lock<std::mutex> lock (mtx);
    cond_var.wait (lock, [&] { return value.load (mem_ord) != 0; });
}

notify_thread.join ();

guaranteed to terminate or may it deadlock? What if one would use mem_ord = std::memory_order_relaxed? May there be any other reasons to hold a lock while store-ing into the atomic<int>? cppreference.com demands that one has to uncomment the line with the lock-guard in the notify_thread.

I would expect that (with any memory order) the store happens-before the notify, which happens-before the (potential) wakeup in the wait, which happens-before the load. (I say "potential wakeup" because the notify-thread may, of course, finish before the wait on the condition-variable in which case there never will be a wakeup). So, I would assume that (with any memory order) there is no need to uncomment the line with the lock-guard.