How to free a linked list properly

Having a task that requires freeing a linked list I used this first code below. But there were some errors [what errors?] in the checker [what checker?] and instead it was suggested that I use the second code snippet. But I can't seem to see the difference. Why would the first one be considered wrong when the address of the next node is stored in the variable tmp? And wouldn't it be lost when freeing the memory allocated in the head variable?

First code:

while (head)
{
	tmp = head->next;
	free(head);
	head = tmp;
}

Second code:

while (head)
{
	tmp = head;
	head = head->next;
	free(tmp);
}

Finally, having these two options, which one is considered to be more accurate and efficient logic wise?

Given that the declarations of the variables involved are exactly the same in both versions, the two versions indeed effectively do the same thing.

There's no reason I can think of why one should be preferred over the other.

Interestingly, when compling this with gcc, both versions produce exactly the same assembler code:

free1:
        test    rdi, rdi
        je      .L9
        push    rbx
        mov     rbx, rdi
.L3:
        mov     rdi, rbx
        mov     rbx, QWORD PTR [rbx]
        call    free
        test    rbx, rbx
        jne     .L3
        pop     rbx
        ret
.L9:
        ret

Demo

... and the same goes for clang, which produces the below for both versions:

free1:                                  # @free1
        test    rdi, rdi
        je      .LBB0_4
        push    rbx
.LBB0_2:                                # =>This Inner Loop Header: Depth=1
        mov     rbx, qword ptr [rdi]
        call    free@PLT
        mov     rdi, rbx
        test    rbx, rbx
        jne     .LBB0_2
        pop     rbx
.LBB0_4:
        ret

Demo