Long jump to 32-bit code does not seem to take effect after switching to protected mode

Question

After much debate with myself, I have finally decided to move my OS to Protected Mode. However, I am having a few issues executing Protected Mode code. The first step on the OSDev wiki was to enable the A20 line, something I had little trouble with because of the fast gate. The second part was loading the Global Descriptor Table. I followed the BrokenThorn Entertainment tutorial and used it as a rough base for my GDT, and translated some of the long binary values to nice and short hex values. Finally, I set the lowest bit of the cr0 register to 1 to enter protected mode. I then made the far jump to 0x08:start32. Upon executing my code, however, and monitoring the registers using qemu's monitor -stdio flag, I see unexpected results. My main protected mode routine, start32, is simple. It moves the value 0xDEADBABA into the eax register. This however does not seem to take effect, as on QEMU, the value is shown to be 00000100. The cr0 register is 00000010, which seems to be correct, but once again makes me skeptical as it is not the lowest bit that is one. The worst one by far is the GDT register, which is equal to precisely 00000000 00000000. What is the problem here? I have provided code for both my bootsector and my part of the kernel that switches to Protected Mode below.

P.S: The bootsector clears the screen and loads the kernel. That is its only purpose.

start.asm (bootsector):

bits 16

start:
    mov ax, 0x07C0
    add ax, 288
    mov ss, ax
    mov sp, 4096

    mov ax, 0x07C0
    mov ds, ax

    mov ah, 0x00
    mov al, 0x03
    int 0x10

    call load_kernel

load_kernel:
    mov ah, 0x02                ; call function 0x02 of int 13h (read sectors)
    mov al, 0x01                ; read one sector (512 bytes)
    mov ch, 0x00                ; track 0
    mov cl, 0x02                ; sector 2
    mov dh, 0x00                ; head 0
    mov dl, 0x00                ; drive 0, floppy 1
    mov bx, 0x2000              ; segment 0x2000
    mov es, bx                  ; segments must be loaded from non immediate data
    mov bx, 0x0000              ; start of segment -offset value
.readsector:
    int 13h                     ; call int 13h
    jc .readsector              ; error? try again

    mov ax, 0x2000              ; set the data segment register
    mov ds, ax                  ; as a pointer to the kernel's memory location

    jmp 0x2000:0x0000           ; jump to the kernel

times 510-($-$$) db 0
dw 0xAA55

kernel.asm (problematic file):

bits 16

section .text
start:
    mov ax, 0x2000
    add ax, 288
    mov ss, ax
    mov sp, 4096

    mov ax, 0x2000
    mov ds, ax

    cli    

    in al, 0x92
    or al, 2
    out 0x92, al

    lgdt[toc]

    mov eax, cr0
    or eax, 1
    mov cr0, eax

    jmp 0x08:start32

section .rodata
gdt32:
    dd 0
    dd 0

    dw 0x0FFFF
    dw 0
    db 0
    db 0x9A
    db 0xCF
    db 0

    dw 0x0FFFF
    dw 0
    db 0
    db 0x92
    db 0xCF
    db 0
gdt_end:
toc:
    dw gdt_end - gdt32 - 1
    dd gdt32

bits 32
section .text
start32:
    mov eax, 0xDEADBABA