Currently Correct Answer

It does not translate system calls.

System calls are usually not made by the software under windows itself, but through normal calls to shared system libraries¹. The windows API that software uses is mostly a normal library API and not focussed on system calls (most of which are considered private and not to be used by software that's not part of windows at all), which allows Windows to implement a rather impressive long-term compatibility.

So, wine implements the API, but not the windows system calls - it couldn't even do that, it's userland software, and hence couldn't catch a software interrupt.

By the way,

As long as the architectures are the same, it is no wonder that Windows .exe file can run on the Linux system

undersells the differences in calling conventions, file abstraction, object file formats and a lot of other things. It's not that easy to let a piece of software written for the interfaces used on a different operating system run successfully, making calls and exchanging memory with your native system.

¹ this is quite like you use C functions like read, which implement the POSIX/libc and Linux API, normally, and rarely do system calls yourself. You'll rarely find someone doing syscall(SYS_READ, …) if they're not trying to write a libc.

Finer Answer, Speculation

Wine still can't, and it's not clear it will ever. Wine-staging can, experimentally as it is, if you enable the right patches.

While the above is true for most things that WINE emulates, as @mbrig points out in the comments, starting ca. 2019, wine-staging does have the ability to trap Windows syscalls. It does that by using Linux' seccomp functionality.

Seccomp was invented to let processes tell the kernel, for example:

Hey, dear kernel, I'm a server, and I've just set up all my listening sockets. There's going to be no reason for me to do syscalls beyond what is necessary to serve websites, so if I do any syscall but exit, read, write, and sigreturn, kindly kick me in my binary bottom.

It does so by doing a prctl syscall with the PR_SET_SECCOMP parameter.

As that's a bit inflexible, later on, the ability for processes to actually define a piece of program supposed to check whether a syscall and it's arguments are OK, was added. Such a filter, however, needs to be defined as a BPF program at the time you're making the prctl(PR_SET_SECCOMP,…) syscall. You also specify which function the resulting signal handler should run.

Now, WINE can do exactly that, and basically does nothing but check whether the syscall made from within a WINE process does fall above a range that's used for Linux syscalls. If it's not, the syscall is allowed to proceed as normal, if it is, SIGSYS is raised, and a dispatcher for the individual Windows syscall is executed.

Small problem: As far as I could find in the official mainline wine repository, this patch hasn't made it to "end-user" wine yet. 3 years is a bit of a long time for a patch to linger in that limbo, and I'd like to think that's because this approach has issues (performance impact, and issues when used in conjunction with security mechanisms), and might or might not be a mechanism that gets included in mainline wine, i.e. the piece of software that you'd refer to as wine.