
<p class="has-drop-cap wp-block-paragraph">1Blott 20 dagars uppehåll hann det vara på Vincennes (första start kl. 16.03) efter vintermeetinget tog slut innan den franska nationalarenan sparkar igång sin vårsäsong denna fredagkväll.</p>



<p class="wp-block-paragraph">Banan raketstartar med dubbla semi classique-lopp för treåriga inhemska sadelhästar i form av Prix Ali Hawas (€120.000) och Prix Felicien Gauvreau (€120.000), men båda rids utan svenska inslag.</p>



<p class="wp-block-paragraph">Gott om blågula inslag finns det däremot i Prix Canopus (€53.000) för sex- och sjuåriga hästar som tjänat upp till 159.000 euro.<br><strong>Chitchat</strong> (e. Maharajah) blev Daniel Wäjerstens första vinnare som tränare på fransk mark då han vann på Enghien för två veckor sedan och jagar nu en ny triumf i lag med Benjamin Rochard.<br>Loppet innehåller även Tomas Malmqvists <strong>Iron Jet </strong>(e. Charly du Noyer), Dominik Locqueneuxs <strong>Halo Am </strong>(e. Father Patrick) och Laurent Claude Abrivards<strong> Invader Am </strong>(e. Muscle Hill).</p>



<p class="wp-block-paragraph">Tomas Malmqvist luftar ytterligare två hästar i fyraåringsloppet Prix Ate (€46.000) i form av <strong>Kash Madrik </strong>(e. Ready Cash) och <strong>Koelho de Nappes</strong> (e. Charly du Noyer) med övriga sex lopp avgörs utan svenskhopp.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-03-22/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2Örebro (start 18.20) och Umåker (start 18.30) delar fredagskvällens expresstrav och en intressant fyraåring gör årsdebut – och dessutom i ny regi. När Svante Båths tränarrörelse avyttrades i slutet av förra året flyttade bland annat <strong>Kaiser Mearas</strong> (e. Readly Express) till Maria Törnqvist.</p>



<p class="wp-block-paragraph">Hästen inledde med tre segrar och lika många andrapris på sex starter, innan han slutade femma i Kriteriekval. Bland annat travade han 1.12,6ak redan i livets fjärde start i somras. I comebacken står han tufft inne på pengarna från tillägg när Carl Johan Jepson hoppar upp i sulkyn.</p>



<p class="wp-block-paragraph">Snabbloppet ser några spännande namn på väg upp i gulddivisionen. Claes Svenssons kapable<strong> King of Everything</strong> (e. Quite Easy) har inte långt kvar till guld efter tre triumfer i försök i silverdivisionen, medan Stefan P Petterssons fartfyllde femåring<strong> Friend of Elves </strong>(e. Oasis Bi) – femma och sexa i Sprintermästaren respektive Kungapokalen förra året – kan klättra en bra stund i rikstotons näst lägsta klass med 1,1 miljoner på kontot.</p>



<p class="wp-block-paragraph">Redan inne i STL:s högsta liga är kvällens stora hemmahopp <strong>Power Doc</strong> (e. Muscle Massive), som slipper skor under hovarna i årsdebuten, och<strong> Mr Mah Can</strong> (e. Maharajah), som bröt en 1,5 år lång förlustrad när han vann ett liknande lopp hemma på Axevalla förra veckan.</p>



<p class="wp-block-paragraph">Två tredjedelar av Umåkers avdelningar utgörs av andra försöksomgången av tre i Umåkermästaren, där hästar i tre klasser möts i en final från tre olika volter den 26 april. </p>



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



<p class="has-drop-cap wp-block-paragraph">3<strong>Beacon Kronos</strong> (e. Father Patrick) var fyra i Svenskt Travkriterium 2020 och finalist i Kungapokalen året därpå i Daniel Rdéns regi, men har såväl blandat och gett i sina prestationer efter det som haft svårt att tävla kontinuerligt. Senaste starten gjordes i Gävle för nästan 17 månader sedan.</p>



<p class="wp-block-paragraph">Numera leasas valacken av Östersundsproffset Oscar Berglund och efter att ha kvalat med tränaren i vagnen på 1.17,0/2.140 meter i söndags blir det tävlingscomeback redan ikväll på Umåker, där han dragit spår sju i ett sprinterlopp tillsammans med Ulf Ohlsson.<br>– Det blir jäkligt spännande. Det är ingen enkel häst, men spännande om man kommer rätt på honom, berättade Oscar Berglund för Sulkysport inför kvalloppet.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/09/beaconkronosheat-617x333.jpg" alt="" class="wp-image-111854"/><figcaption class="wp-element-caption">Beacon Kronos. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Årsdebut, men inte alls lika långt uppehåll, handlar det om för ett av landets bästa treåriga ston förra året. Robert Skoglund tränar <strong>Ängspuma</strong> (e. Ängsborken), som avslutade fjolåret med fyra raka segrar, däribland Svensk Travsports Treåringsstjärna med sexsiffrig segercheck. Årsdebuten blir en tuff uppgift, blott sju motståndare till trots. 60 meter framför startar nämligen Jan-Olov Persson-tränade hingsten <strong>Eld Messi </strong>(e. Tekno Odin), som avlade maiden i tisdags.</p>



<p class="wp-block-paragraph">Fredagen inleds med lunchtävlingar på Jägersro (start 12.20) där 84 hästar fördelats i sju spårtrappor med tolv hästar i varje. Spännvidden är förstås störst i högsta klassen med bland annat Tomas Malmqvists gulddivisionsfyra från försöket i Halmstad, <strong>Digital Dominance</strong> (e. Super Photo Kosmos), inleder från spår åtta.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/03/240322.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>



<p class="has-drop-cap wp-block-paragraph">4 Frode Hamre har kungjort att hans färska Gulddivisionsvinnare <strong>Stoletheshow</strong> (e. Dream Vacation) tar sikte mot Klosterskogen Grand Prix nästa lördag i Skien och där får han sällskap av en annan norskfödd topphäst.</p>



<p class="wp-block-paragraph">Björn Goop-tränade <strong>Moni Viking</strong> (e. Maharajah) tar nämligen samma väg och kommer anmälas till 800 metersbanans största lopp för året vilket avgörs över 2.100 meter autostart med ett förstapris på 175.000 norska kronor.<br>&#8221;<em>Därefter ska han verka som avelshingst hemma hos ägaren en stund för att betäcka</em>&#8221;, informerar Björn Goop i ett sms till Sulkysport.</p>



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



<p class="has-drop-cap wp-block-paragraph">5Det gick undan värre när 2018 års Olympiatravstrea <strong>Titty Jepson</strong> (e. Varenne) 1.10,5/€369.240 hade sin förstfödda avkomma till start under onsdagseftermiddagen i Rom.</p>



<p class="wp-block-paragraph">Alessandro Gocciadoro tränar <strong>Free Time Jepson</strong> (e. Face Time Bourbon) som i hans nypor dundrade runt på 1.14,3a/2.100 meter i karriärens första start och vann med fem längder som marginal.</p>



<p class="wp-block-paragraph">Free Time Jepson ropades in för 60.000 euro på Its Aste-auktionen för två år sedan och ägs av Scuderia Chelsea Srl som även hade en onsdagsvinnare i Sverige i form av Per Nordström-tränade <strong>Zipzoranda</strong> (e. Googoo Gaagaa).</p>



<p class="wp-block-paragraph">Free Time Jepson är anmäld till E3 och kan med andra ord komma att dyka upp på svensk mark under året.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/04/tittyjepsonheat-617x329.jpg" alt="Titta Jepson och Alexandre Abrivard, Sulklysport" class="wp-image-21543"/><figcaption class="wp-element-caption">Titty Jepsons förstfödda avkomma imponerade stort i tävlingsdebuten. Foto Jean-Philippe Martini </figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">6Den danska topphästen <strong>Extreme</strong> (e. Chocolatier) har inte synts till i tävlingssammanhang sedan andraplatsen i Paralympiatravet år 2022, men nu närmar han sig äntligen comeback.</p>



<p class="wp-block-paragraph">Efter att flyttats från Steen Juul till Flemming Jensen under fjolåret så stundar nu start på den nya tränarens hemmabana fredag den 5 april. Propositionen är ett vanligt snabblopp över 2.140 meter autostart med 20.000 danska kronor i segerpremie.<br>– <em>Tanken var att starta hästen i ett provlopp den 22 mars, men det har vi släppt och går nu istället för start den 5 april</em>, <a href="https://travservice.dk/intet-rutineloeb-til-extreme-foer-comeback/" target="_blank" rel="noreferrer noopener">säger Flemming Jensen till Travservice.dk.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7Efter några fredagar med tunnare utbud ser det helt annorlunda ut på ASVT:s internetauktion denna vecka.</p>



<p class="wp-block-paragraph">Elva objekt finns ute för försäljning och bland dem finns det fyra treåriga hästar.<br><strong>Lingonris</strong> (e. Prodigious) sticker måhända ut då hennes mor <strong>Cyklamen</strong> (e. Ready Cash) är halvsyster till självaste <strong>Earl Simon </strong>(e. Prodigious) 1.09,9/€1.028.685.</p>



<p class="wp-block-paragraph">Det säljs även en treårig dotter till just Earl Simon i <strong>Simonette Noir </strong>och bakom såväl Lingonris som Simonette Noir står Zandra Widén som säljare.</p>



<p class="wp-block-paragraph"><a href="https://auktion.asvt.se/purchase/" target="_blank" rel="noreferrer noopener">Här kan du ta del av kvällens utbud på ASVT:s auktion.</a></p>

Fokustema
Morgonsvepet
Läs senare
Underbart är kort
Om de blågula hoppen under Vincennes vårpremiär, Kriteriefyra i efterlängtad debut för ny tränare samt norskt "drömmöte" på Klosterskogen går bland annat att läsa i veckans femte morgonsvep.
