I am programming in Java, and I always make converters sort of like this:

public OtherObject MyObject2OtherObject(MyObject mo){
    ... Do the conversion
    return otherObject;
}


At the new workplace the pattern is:

public void MyObject2OtherObject(MyObject mo, OtherObject oo){
    ... Do the conversion
}


For me it is a little bit smelly, as I got used to not to change the incoming parameters. Is this incoming parameter alteration an antipattern or is it OK? Does it have some serious drawbacks?

It's not an antipattern, it's a bad practice.
The difference between an antipattern and a mere bad practice is here: anti-pattern definition.
The new workplace style you show is a bad practice, vestigial or pre-OOP times, according to  Uncle Bob's Clean Code.

Arguments are most naturally interpreted as inputs to a function.
Anything that forces you to check the function signature is equivalent
to a double-take. It’s a cognitive break and should be avoided. In the
days before object oriented programming it was sometimes necessary to
have output arguments. However, much of the need for output arguments
disappears in OO languages

