
<p class="has-drop-cap">1Årets Tvååring i Sverige 2025, <strong>Cruiser</strong> (e. Calgary Games), charmade på travbanorna i fyra starter på sensommaren och tidiga hösten förra året när hon vann samtliga lopp, däribland Breeders Course-finalen för tvååringar, Sweden International Yearling Sales Auktionslopp och ett Breeders Crown-lopp.</p>



<p>Triumfen i Breeders Course på nytt europarekord – 1.12,1a/1.640 meter – blev sista starten ifjol. Ikväll på <strong>Jägersro</strong> (första start 18.27) är det dags för årsdebut i ett försök till Breeders Course med final på Elitloppsdagen med en miljon kronor till vinnaren.</p>



<p>Cruiser är den klarast lysande stjärnan i femhästarsfältet, där den mest meriterade av motståndarna är en annan årsdebutant, Dion Tesselaar-tränade <strong>Rosie Bros</strong> (e. Maharajah), som var trea bakom Cruiser i två svenska starter förra året.</p>



<p>Tre finalister i Svensk Uppfödningslöpning möts i försöket för hingstar och valacker. Per Nordström-tränade <strong>Victorious Tile</strong> (e. Chapter Seven) lyckades bäst där med fjärdeplatsen, medan Johan Untersteiners <strong>All Dimensions</strong> (e. Fourth Dimension) var femma och Erwin Bots <strong>Revanche Boko</strong> (e. Face Time Bourbon) slutade sexa.<br>Victorious Tile är den ende i trion som årsdebuterat, då han slutade tvåa i Breeders Crown-försök i Örebro för tre veckor sedan.</p>



<p>De övriga försöken körs på Solvalla den 6 maj och i Milano den 19 maj. De två främsta i varje går till final, medan övriga finalplatser tillsätts genom anmälan.</p>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/9barackface1-617x333.jpg" alt="" class="wp-image-509536"/><figcaption class="wp-element-caption">Barack Face höll stången gentemot Just A Gigolo i en tät slutstrid i Europaderbyt 2023. Foto Mathias Hedlund/Sulkysport.se</figcaption></figure>



<p class="has-drop-cap">2Tävlingsskorna lades på hyllan förra året efter 27 starter (8-3-1). På meritlistan stack triumfen i Europaderbyt och silverpengen i Svenskt Travderby 2023 ut.</p>



<p>På Jägersro ikväll gör <strong>Barack Face</strong> (e. Ready Cash)1.11,1am/6.569.899 kr, gör comeback efter nästan ett års tävlingsuppehåll. Numera är det Lutfi Kolgjini som tränar hingsten, som körs av tidigare tränaren Adrian Kolgjini från spår åtta bakom bilen i snabbloppet som är utskrivet som en spårtrappa.</p>



<p>– Det syntes på honom i hagen att han började friskna till så att säga. Det visade sig att han hade en bakterie i lungorna som det krävdes en långvarig antibiotikabehandling för att bli av med. Men när han hade varit bra i ett par månader, så beslöt jag att vi skulle prova att köra i gång honom igen och se vad fan som skulle hända, säger Lutfi Kolgjini till Kanal75.</p>



<p>Sprinterloppet ligger på V86-kupongen och ”Luddes” formrapport om mångmiljonären lyder:</p>



<p>– Som snabbast har han gått 1.15/1.600 meter här hemma på ”rakan”. Så han har inte varit inne till Jägersro och gått något där alls, jag har inte velat utsätta honom för någon onödig stress. Jag tror att han kommer göra ett mycket fint lopp, det är jag ganska så säker på, men sedan hur långt det räcker, det står nog skrivet i stjärnorna ännu, säger Kolgjini till Kanal75.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/04/29v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/fylkingkarlgosta-617x333.jpg" alt="" class="wp-image-435378"/><figcaption class="wp-element-caption">Karl-Gösta Fylkings lopp avgörs på Solvalla under onsdagskvällen. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">3Den 3 februari 1992 vände Karl-Gösta Fylking upp och segerdefilerade på hemmabanan med <strong>Pagan</strong> (e. Crowning Point) efter karriärens 1.169:e seger. Då sade hjärtat stopp, han föll ur sulkyn och 55 år gammal hade en av svensk travsports stora profiler hastigt ryckts bort.</p>



<p>Karl-Gösta Fylking – eller ”Korpen” – var en skicklig hästkarl som gick hem i alla läger. Hans popularitet var stor med glimten i ögat och som humörspridare, och för publiken blev han ”småspelarnas vän”.</p>



<p>1955 vann han sitt första lopp med <strong>Sigrun</strong>, som tränades av pappa Gösta. Den seger skulle följas av många fler. Bland storloppsvinsterna finns Svenskt Travderby (Guy Nibs 1967), Svenskt Trav-Oaks (Divina Tilly 1981), (Sprintermästaren (Pelle J:r 1973) och Svenskt Mästerskap (Speedy Min 1980). Som tränare var dubbelmiljonären och elithästen <strong>Hanzie V.</strong> (född 1981 e. Second Boy) hans kanske bästa häst.</p>



<p>1960 vann Kalle Fylking lärlingsfinalen Guldklockan på Solvalla och när huvudstadsbanan efter ”Korpens” bortgång skapade ett minneslopp var det ett lärlingslopp som gällde.</p>



<p>Ikväll på <strong>Solvalla</strong> (första start 18.15) är det dags för årets upplaga och loppet tar plats på V86-kupongen. Malte Handfast får chansen bakom arbetsgivaren Christoffer Erikssons formkort <strong>Nice Run</strong> (e. Flocki d’Aurcy), som ståtar med tre raka segrar i vår.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/gaminjabajph260422adamstromstalltz-617x439.jpg" alt="" class="wp-image-843542"/><figcaption class="wp-element-caption">Gamin Jaba och Jennifer Persson. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Flera franska mångmiljonärer startar i Solvalla Hästägarförenings Montépokal med 100.000 kronor till vinnaren. Sabine Kagebrant-tränade <strong>Lovissime</strong> (e. Love You) har firat stora framgångar under sadel i Frankrike och vann montéloppet Prix Indienne (€71.000) på Vincennes i början av februari. För Daniel Redéns fransos <strong>Gamin Jaba </strong>(e. Kesaco Phedo) handlar det däremot om debut i disciplinen när Jennifer Persson hoppar upp i sadeln.</p>



<p>Sulkysports expertpanel visade härlig tipsform i lördagens V85-omgång i Örebro där fyra av omgångens åtta vinnare lyftes fram! Både <strong>Clarissa</strong> och <strong>Speed Change</strong> förordades som spikar och <strong>Maker&#8217;s Wall Ås</strong> (av två tipsters) och <strong>Tiberius Victory</strong> var skrällbud.</p>



<p>Ikväll är jackpot på V86 när 14.257.074 kronor extra ligger i åttarättspotten, som tros landa på minst 23 miljoner kronor enligt ATG:s prognos. Bästa spikarna och skrällbuden presenteras vid lunchtid idag.</p>



<p><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p><a href="https://www.atg.se/butik/simsalabim/V86_2026-04-29_40_1" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos Simsalabim.</a></p>



<p><a href="https://www.atg.se/butik/69ansspel/V86_2026-04-29_40_1" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos 69:ans Spel &#038; Tobak.</a></p>



<p><a href="https://www.atg.se/butik/spelpoolen/V86_2026-04-29_40_1" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos Spelpoolen.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">4 Idag årsdebuterar storstjärnan <strong>Alrajah One </strong>(e. Maharajah-Mariu), 1.08,6ak/€1.654.944, i nygammal regi i Florens i Premio Glauco Cicognani (€11.000) för Alessandro Gocciadoro.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/07/wb070222r6alrajahoneit-617x346.jpg" alt="" class="wp-image-322606"/><figcaption class="wp-element-caption">Dexter Dunn och Alrajah One. Foto: Lisa Photo</figcaption></figure>



<p>I hans regi vann Alrajah One Italienskt Derby, Gran Premio Citta di Padova, Gran Premio Continentale, Gran Premio Giuseppe Biasuzzi, Gran Premio d’Europa och Gran Premio Freccia d’Europa.</p>



<p>Senare gick hästen till Åke Svanstedt och där det blev åtta starter, fem segrar och 734.345 intjänade dollar. Alrajah One vann flera penningstinna löpningar; Maple Leaf Trot (C$530.000), John Cashman Memorial ($279.000), Spirit of Massachusetts ($250.000), Crawford Farms Open Trot ($147.000) och Allerage Farms ($135.000).</p>



<p>Efter skador och återkomst till Europa har hingsten tränats av Erik Bondo och Marco Azzaroni/Mauro Baroncini och idag startar han i Florens klockan 17.50 över distansen 2.020 meter, autostart.</p>



<p><strong>Startlista: </strong>1 Elettra Op, 2 Enea Sl, 3 Alrajah One, 4 Eisenhower Effe, 5 Burraio Op, 6 Cralgido Sm.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">5 Den 17 maj avgörs Mallorcas största lopp – Gran Premi Nacional (€100.000) – för treåringar på San Pardo.</p>



<p>Bland de 16 som får starta finns Annemannas <strong>Nando</strong> (e. Love You-Inca), 1.19,3/€1.958, vilken tränas av Juan Candil Bauzzas och som vunnit två av sju starter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/skarmavbild20260428kl.13.44.59-617x383.jpg" alt="" class="wp-image-843539"/><figcaption class="wp-element-caption">Nando. </figcaption></figure>



<p><strong>Nike de Font</strong> (e. Celtic Commander-Glamour Font e. From Above), 1.16,8am*/€16.450, är fältets vinstrikaste travare och han har vunnit åtta av 14 starter.</p>



<p><strong>Gran Premi Nacional</strong> (€100.000)<br>Treåringar.<br><strong>Prissumma:</strong> 46.000-23.000-12.000-7.000-5.000-3.500-2.500-1.000 euro.<br>2.150 meter, autostart.</p>



<p><strong>Namn (far) </strong></p>



<ul class="wp-block-list">
<li><strong>Nike de Font</strong> (e. Celtic Commander)</li>



<li><strong>Nico de Font</strong> (e. Celtic Commander)</li>



<li><strong>New Bomber Mar</strong> (e. Maharajah)</li>



<li><strong>Nokia Mar</strong> (e. Andover Hall)</li>



<li><strong>Natan de Font</strong> (e. One Too Many)</li>



<li><strong>Nuambba</strong> (e. From Above)</li>



<li><strong>Nuredduna des Bosc</strong> (e. Royal Dream)</li>



<li><strong>Nancy Atac</strong> (e. Infinitif)</li>



<li><strong>Nomurita Mar</strong> (e. Toronto As)</li>



<li><strong>Nostro Veix </strong>(e. Maharajah)</li>



<li><strong>Nash Cege</strong> (e. As de Muze)</li>



<li><strong>No Pain No Gain</strong> (e. Muscle Massive)</li>



<li><strong>Nando</strong> (e. Love You)</li>



<li><strong>Nelson de Nit</strong> (e. One Too Many)</li>



<li><strong>Neylan</strong> (e. Mage de la Merite)</li>



<li><strong>N’Estela Vx</strong> (e. Maharajah)</li>



<li><strong>Naskar des Puig</strong> (e. Yankee Slide)</li>
</ul>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">6 På Preferred Equine Online Sale i måndags köpte Robin Thörn treåriga stoet <strong>Mondrian</strong> (e. Muscle Hill-Ready Donna), 1.12,0/$1.790, för 16.000 dollar.</p>



<p>– Hon betäcks med Maryland, berättar Robin Thörn.</p>



<p>Stefan ”Order By Stable” Balazsi har fött upp Mondrian, vilken kostade 50.000 dollar som ettåring på Lexington Selected Yearling Sale.</p>



<p>Hennes mor <strong>Ready Donna</strong> (e. Ready Cash), 1.12,8/$9.410, har sin första avkomma i Mondrian. Hon var själv en dyring som ettåring och såldes för 110.000 dollar på Lexington Selected Yearling Sale. </p>



<p>Mormor <strong>Unica Donna </strong>(e. Donato Hanover-Hangone), 1.12,4/€76.859, har sina främsta avkommor i <strong>Una Madonna</strong> (e. Tactical Landing), 1.09,7/$163.703, och <strong>Uno</strong> (e. Tactical Landing), 1.08,6ak/1.029.182 kr.</p>



<p>Unica Donna är i sin tur halvsyster med dubble Derby-vinnaren och avelshingsten <strong>Daguet Rapide</strong> (e. Pine Chip), 1.11,4/€1.391.182, vilken vann sju Grupp I-löpningar.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">7 Hos Madelen och Torbjörn Ohlzon på Långeruds Gård har <strong>Trinidad As</strong> (e. Cantab Hall-Ima Quick), 1.12,0k/333.650 kr, fått en hingst efter Readly Express och det handlar således om en lillebror till <strong>Slipstream Zon</strong> (e. Googoo Gaagaa), 1.11,5am*/666.000 kr, som vann försök till Drottning Silvias Pokal i fredags.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/trinidadas-617x742.jpeg" alt="" class="wp-image-843547"/><figcaption class="wp-element-caption">Trinidad As hingst efter Readly Express. Foto: privat</figcaption></figure>



<p>Modern har också lämnat <strong>Jimbaran Zon</strong> (e. Maharajah), 1.10,1ak/1.004.935 kr. Det kan också noteras att Trinidad As är halvsyster med unghäststjärnan <strong>Quick Credit</strong> (e. Credit Winner-So Help Me), 1.11,7/$553.113, och <strong>Lawyer As</strong> (e. S.J.’s Photo), 1.12,1/€210.614.</p>



<p>Mor har också unghäststjärnan <strong>O’Mara Zon </strong>(e. Maharajah-Exclusive Zon), 1.09,9ak/2.696.000 kr, blivit till ett sto efter Sig Sauer och det är hennes andra avkomma. Ifjol fick hon en dotter efter Francesco Zet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/omarazon-617x741.jpeg" alt="" class="wp-image-843548"/><figcaption class="wp-element-caption">O&#8217;Mara Zons dotter efter Sig Sauer. Foto: privat</figcaption></figure>



<p>Karriären inrymde nio segrar på 25 starter hos Daniel Wäjersten och däribland vinst i Sommarfavoriten för ston, men också en andraplats i korta E3 plus att O’Mara Zon var finaltrea i såväl Breeders Crown som Drottning Silvias Pokal 2023.</p>



<p>O’Mara Zon är undan <strong>Exclusive Zon</strong> (e. Varenne), 1.11,8ak/587.250 kr, som också lämnat <strong>Minnucci Zon </strong>(e. Trixton), 1.12,2ak/469.900 kr, <strong>Randy Zon</strong> (e. Maharajah), 1.11,8ak*/420.450 kr.</p>



<p>Ni vet väl att ni kan maila in fölrapporter för fri publicering? Uppge mor, far och kön på fölet. Skriv också om ni bestämt vilken hingst stoet ska gå till i år och skicka gärna med en bild tagen på bredden.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>
