Better explanation coming soon when I recover from the work put into this.

Better explanation:
Every Befunge-98 quine needs to contain symbols such a @ or q and ,
Problem: None of those symbols are a good starting point especialy since @ and q terminate the program instantly.
Solution: Get rid of those characters in the source code

Problem: How?
Solution: Use p (put) commands to modify the source code to include the required characters which will print the contains of the source code shifted by one byte and not use the g command which is cheating.

Problem: (sigh when will these end)
A put command pops 3 values n x y which determine character, x-coord, y-coord however when the initialization of these values is split in half it can write bad characters in the beginning source code making it useless for quining.
Solution: (last one I promise)
Use 2 copies of the source code, the latter one being the "correct one" this accidentally fixes another problem which is that a put statement (p command + the constant initializers) which is split in half will not get executed, this is fixed by having 2 copies of each statement. Last thing this needs to work is how do we make the whole source code out of a half?

Answer:

This is visual proof of why two copies of a string byte shifted == Two copies of a byte shifted string. That means we can take a half of the code, byte shift it, then print it twice (OR take half of the code, byte shift it, print, repeat [That's what actually happens])

How this is implemented: Assume 0123456789abcdef is the source

Befunge Pseudocode:

0123456789abcv;;"123456789abcdef" < go this way <--
             >PS'0,   repeat 2x   ^

PS means Print Stack (not a real instruction). We push half of the source code in reverse onto the stack using "" then we print the stack and then we fetch (' command) the first character 0 which we move in front of the ' and print it last which causes the byte shift, then we repeat the cycle once more to print the second copy. One technicality to deal with are the symbols inside the source, this can cause trouble if we write it while executing the source code, I circumvented this by adding more put statements which take care of it externally.

This makes the code look something like this:

Explanation:
Green Highlight: Code that takes care of adding characters into the source
Grey Letters (probs poor visibility sorry): Code that gets added by green code
Red Highlight: Code that moves first character of the second half of source code into the Blue area.
Blue Highlight: See Red Highlight
Orange Highlight: Code that makes sure we terminate after we wrote 2 byte shifted copies by putting a @ (terminate) command into the Yellow Area.

Arrows should hopefully make it clearer how the code flow goes.

Here comes the last tough part:
Where do babies source code come from?

Short answer: C# Magic
Long answer: 100+ Befunge code snippets made by hand compiled by C# code. I manually wrote about 100 constant initializers (a piece of befunge code that pushes a certain number to stack) by hand and then used a custom C# program to compile it into the 1300 byte Befunge output, which I then copy pasted twice and made the final program.

Are you still here? Great thank you for reading! (or at least scrolling to the end)
I hope my bad jokes were fun and not annoying.

Befunge-98 (PyFunge), 2600 bytes, Not Fully Verified

This was a hell to make. I tested for the worst edge cases I could think of but I need a program to fully verify it.

If anyone can please test the validity of the program I'd be very grateful.
Better explanation coming soon when I recover from the work put into this.

Befunge-98 (PyFunge), 2600 bytes

This making this was a hellfest.

Better explanation coming soon when I recover from the work put into this.

EDIT: I have verified the code using the following Javascript code in TIO using developer tools

setInterval(()=>{document.getElementById("code").value = 
document.getElementById("output").value; 
document.getElementById("run").click();}, 2000);