
<p class="has-drop-cap wp-block-paragraph">1Förra året årsdebuterade <strong>A Fair Day</strong> (e. Maharajah) på årsbästa i Sverige när han vann i slutet av mars Prins Carl Philips Jubileumspokal på Färjestad på 1.09,5a/1.640 meter tillsammans med Oscar Ginman. Ikväll är Kalmars flaggskepp och fjolårets Elitloppsdeltagare tillbaka på tävlingsbanan för att inleda en ny säsong. Och det blir med en nybliven 18-åring i vagnen.</p>



<p class="wp-block-paragraph">Oscar Ginman har kört hästens samtliga 37 starter, men är avstängd ikväll och då väljer tränaren Elisabeth Almheden Noa Reldén – 19 segrar på 33 starter förra året i juniorchansen – som kusk.<br>– Tyvärr är Oscar avstängd, men han är ”min” kusk och ska köra i fortsättningen. Noa har visat sig ha talang och brinner för travet, vi behöver ungdomarna. Jag vill ge Noa chansen, säger Elisabeth Almheden till Kanal75.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/elisabethalmheden2-617x333.jpg" alt="" class="wp-image-523532"/><figcaption class="wp-element-caption">Elisabeth Almheden kramar om Oscar Ginman efter en seger för A Fair Day. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Efter att ha avslutat fyraåringssäsongen med vinst i Breeders Crown-finalen gjorde A Fair Day 13 starter (5-3-1) förra året, där största segern kom i C.L. Müllers Memorial i oktober.<br>– A Fair Day känns väldigt bra, minst lika bra som inför förra säsongen. På slutet har han fått börja med lite intervaller och hästen känns väldigt fin och löpsugen. Jag tycker också att han har lagt på sig ännu mer muskler. Det här loppet passar bra och det är på hemmaplan, säger Almheden till Kanal75.</p>



<p class="wp-block-paragraph">A Fair Day ställs mot sex konkurrenter och har spår längst ut bakom vingen i spårtrappan över 1.640 meter med bilstart.</p>



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



<p class="has-drop-cap wp-block-paragraph">2A Fair Days lopp inleder kvällens V64-express, där Kalmar (första start 18.30) delar omgången med Boden (start 18.20) som bjuder 15-13-15 i sina tre avdelningar på det stora streckspelet. </p>



<p class="wp-block-paragraph">Bland annat tar Sandra Eriksson ut sitt kallblodsess <strong>Gorm</strong> (e. Dotterud Teddy) i årsdebut. Hästen tog första segern på över två år när han vann i finska Uleåborg i mitten av december, och första vinsten i Sandras regi. Nu startar nioåringen från 60 meters tillägg.</p>



<p class="wp-block-paragraph">Ett par spännande ämnen i norr dyker upp i treåringsloppet. Sören Lennartson-tränade <strong>Millenium U.M.</strong> (e. Don Fanucci Zet) började med två segrar på tre försök som tvååring och inledde treåringssäsongen med andraplats i en avdelning i Margaretas Tidiga Unghästserie.<br>Nu jagar hon 20 meter bakom Petri Salmela-tärnade <strong>Kobra Brick</strong> (e. Readly Express), som är fortsatt obesegrad efter två starter.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Mattias Djuse tar ut en högintressant, treårig debutant i nolloppet på lunchbanan Romme (start 12.20) idag. Det handlar om högättade <strong>The Pope</strong> (e. Father Patrick), som har äldre syskon med unghästmeriet att leva upp till.</p>



<p class="wp-block-paragraph">Modern <strong>Red Rose America</strong> (e. Varenne) tjänade 4,5 miljoner kronor och har tidigare lämnat danske Kriterietvåan <strong>Godfather</strong> (e. Bold Eagle) och fjolårets svenske Kriteriefyra <strong>Preacherman</strong> (e. Father Patrick). Båda dessa tränades av Ola Samuelsson vid framgångarna.</p>



<p class="wp-block-paragraph">I ett av Rommes kallblodslopp startar Annelie Lagergren sina nya segermaskin. Sexårige <strong>Perto</strong> (e. Lome Brage) debuterade visserligen först sent som femåring, men sedan dess har det mesta gått som på räls. Fyra segrar och ett andrapris (i debuten) är resultatet på fem starter.<br>Jorma Kontio kör från springspår på tillägg och tillsammans jagar duon fjärde raka segern.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/03/250321.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/jolicoeurscoopdyga-617x411.jpg" alt="" class="wp-image-678482"/><figcaption class="wp-element-caption">Constanza Flores och Jonathan Carres svenskfödde sexåring Jolicoeur vann direkt i Vincennesdebuten i januari. Foto Scoopdyga</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Den 1 mars avslutades det franska vintermeetinget på Vincennes. Efter tre veckors uppehåll drar tävlingarna igång igen på kolstybben i Paris idag med start klockan 16.03.</p>



<p class="wp-block-paragraph">Tre svenskfödda travare sluter och upp och trion <strong>Jolicoeur</strong> (e. Atlas des Joudes), <strong>Hashtag Simoni</strong> (e. Orlando Vici) och <strong>Mister Invictus</strong> (e. Ready Cash) möts i Prix Canopus (€53.000) med 23.850 euro till vinnaren.</p>



<p class="wp-block-paragraph">Jolicouer var en av 13 svensktränade och svenskfödda hästar (15 triumfer) som vann under vintermeetinget, då han tog hem sin Vincennesdebut i Prix de Pont-Audemer (€41.000) i regi Constanza Flores och Jonathan Carre. När duon vände hem till Sverige efter ett par månader i Frankrike gick hästen i träning till Mathieu Mottier, där han inledde med tredjeplatsen i Prix de Larre (€46.000).<br>De svenska motståndarna ikväll, Hashtag Simoni och Mister Invictus, tränas av Erik Bondo respektive Thierry Duvaldestin.</p>



<p class="wp-block-paragraph">I inledande treåringsloppet tar Ron Kuiper ut <strong>Marie Jose Labelle</strong> (e. Alto de Viette), som efter vinst i debuten som tvååring gått segerlös ur tre raka starter.</p>



<p class="wp-block-paragraph">Kvällens största löpningar är två Grupp II-klassade sadellopp för treåringar, Prix Ali Hawas (€120.000) för ston och Prix Felicien Gauvreau (€120.000) för hingstar.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-03-21/lopp-1/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vincennes tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Fjolårets danske Derbytvåa <strong>Jigger</strong> – sprungen ur Fabulous Woods första årgång – fick pris för snyggast uppvisad hingst på avelsvärderingen i fredags på Solvalla. Camilla Juul visade upp hingsten.</p>



<p class="wp-block-paragraph">Jigger, vars mor <strong>Little Jigger</strong> (e. Muscle Hill) är helsyster med dollarmiljonären och framlidne <strong>Bar Hopping</strong>, ska fortsätta tävla för Steen Juul, men också användas till ett begränsat antal ston. </p>



<p class="wp-block-paragraph">Hingstens första partner blir <strong>Isabella C N </strong>(e. Dream Vacation), 1.15,3am/527.875 dkk, som vann Dansk Uppfödningslöpning.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Från tillförordnad till ordinarie på posten. Anna Wersén fortsätter som vd på riksanläggningen Wången i Alsen, skriver travskolan på sin hemsida.</p>



<p class="wp-block-paragraph">Håkan Karlsson slutade efter fem år som verkställande direktör på Wången i februari förra året och i höstas utsågs Anna Wersén till tillförordnad vd. Efter ett halvår på posten tar hon nu över den permanent.<br>– Anna har ju varit en betydelsefull ledamot av styrelsen i flera år och har verkligen tagit sig an uppgiften som vd på ett engagerat och konstruktivt sätt. Det känns väldigt bra att ha Anna i förarsätet för den fortsatta utvecklingen av Wången och dess verksamhet, säger Ulf Hörnberg, styrelseordförande för Wången AB, på Wångens hemsida.</p>



<p class="wp-block-paragraph">Anna Wersén har tidigare arbetat mycket inom turismsektorn som marknads- och försäljningschef på Skistar Åre, vd på Destination Östersund och affärsutvecklingschef för Stiftelsen Jamtli. </p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/derby2-617x361.jpg" alt="" class="wp-image-645739"/><figcaption class="wp-element-caption">Alessandro Gocciadoro-tränade First of Mind segrade i Italienskt Derby för Antonio di Nardo. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7I onsdags hölls första försöksomgången till Gran Premio Citta di Torino (€20.900) för fyraåringar. Idag tar San Siro-banan i Milano över med ett kval för hingstar och ett för ston. </p>



<p class="wp-block-paragraph">Fjolårets italienske Derbyvinnare <strong>First of Mind</strong> (e. Face Time Bourbon) gör sin andra start för Alessandro Gocciadoro i år.  I samma lopp sätter sig Magnus A Djuse bakom Alessandro Gocciadoros nyförvärv <strong>Feldenkrais Pal</strong> (e. Trixton), vilken gör årsdebut och som förra året vann Grupp I-loppet Gran Premio Nazionale i regi Paul Hagoort. <br>Bland motståndarna finns <strong>Felipe Roc</strong> (e. Filipp Roc) och <strong>Fil Ek</strong> (e. Ringostarr Treb), som slutade etta respektive tvåa i det italienska uppfödningsloppet Gran Premio Allevatori. </p>



<p class="wp-block-paragraph">Stona tävlar också i ett försök och där kommer också en högoktanig häst från Gocciadoro-stallet. <strong>Funny Gio</strong> (e. Face Time Bourbon) vann stoavdelningen i Gran Premio Allevatori och ifjol tog hon hem Gran Premio Etruria, Gran Premio Italia, Campionato Femminimile 3 anni, Gran Premio Carlo Marangoni Filly och Orsi Mangelli Filly.</p>



<p class="wp-block-paragraph"><strong>Gran Premio Citta di Torino (€20.900)</strong><br>Fyraåriga hingstar, 2.100 meter, autostart<br><em>Namn (far) – Körsven</em></p>



<ol class="wp-block-list">
<li>Fargo Wise As (e. Walner) – Marco Stefani</li>



<li>Fil Ek (e. Ringostarr Treb) – Pietro Gubellini</li>



<li>Fire Wise As (e. Love You) – Vincenzo P. Dell’Annunziata</li>



<li>Felipe Roc (e. Filipp Roc) – Santo Mollo</li>



<li>First of Mind (e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li>Freyr di Venere (e. Pascia Lest) – Giampaolo Minnucci</li>



<li>Frankie Bar (e. Oropuro Bar) – Andrea Farolfi</li>



<li>Funky Roc (e. Nad al Sheba) – Filippo Rocca</li>



<li>Futuro d’Amore (e. Maharajah) – Francesco Facci</li>



<li>Feldenkrais Pal (e. Trixton) – Magnus A Djuse</li>
</ol>



<p class="wp-block-paragraph"><strong>Gran Premio Citta di Torino (€20.900)</strong><br>Fyraåriga ston, 2.100 meter, autostart<br><em>Namn (far) – Körsven</em></p>



<ol class="wp-block-list">
<li>Fosciandora Dr (e. Nad al Sheba) – Pietro Gubellini</li>



<li>Fragola di No (e. Nad al Sheba) – Marco Stefani</li>



<li>Filly Mail (e. Readly Express) – Santo Mollo</li>



<li>Fan Idole Vf (e. Ideale Luis) – Andrea Farolfi</li>



<li>Flores de Campo (e. Ringostarr Treb) – D Demuru</li>



<li>Faharajah One (e. Maharajah) – Edoardo Loccisano</li>



<li>Fenice del Ronco (e. Maharajah) – Giampaolo Minnucci</li>



<li>Fiaba del Ronco (e. Face Time Bourbon) – Vincenzo Luongo</li>



<li>Funny Girl (e. Vitruvio) – Francesco Facci</li>



<li>Funny Gio (e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li>Freisa Roc (e. Napoleon Bar) – Filipp Rocca</li>



<li>Follow Me Love (e. Owen’s Club) – Andrea Guzzinati</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
”Känns väldigt fin och löpsugen”
A Fair Day får ny kusk efter 37 starter. Kriteiehästar som storasyskon. Vincennes tillbaka efter uppehåll. Tar över vd-stolen permanent. Derbyvinnare på banan igen.
Dessa och fler nyheter i morgonsvepet.
Dessa och fler nyheter i morgonsvepet.
