
<p class="has-drop-cap wp-block-paragraph">1Sju raka segrar och vinterns kung efter segrar i Sylvesterloppet och Bergsåker Winter Trot. I Oasis Bis lopp i eftermiddag på Mantorptravet (första start 14.45) är förutsättningarna annorlunda för Katja Melkkos stjärna <strong>High On Pepper</strong> (e. Ready Cash). Han travar vidare med skor under hovarna medan sju av nio motståndare den här gången tävlar på någon form av barfotabalans.<br>– Ingenting negativt i träning, han har känts så en lång tid. Bakspår passar honom, han är inte snabbast bakom bilen, sade Katja Melkko om megafavoriten till V65 Direkt.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/clickbaitmad-617x333.jpg" alt="" class="wp-image-477046"/><figcaption class="wp-element-caption">Click Bait gör årsdebut i Mantorp och tar striden med vinterns segermaskin High On Pepper. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Kan 2022 års Elitloppsfemma <strong>Click Bait</strong> (e. Cantab Hall) göra något i sin första start sedan i oktober? Stefan Melanders topphäst har sprungit in runt 1,5 miljoner kronor varje år de senaste fyra säsongerna och att Melander väntat in barfotakörning råder inga tvivel om. Att tävla med skor är inte alls ”Clickens” melodi.<br>– Click Bait har inte stått över ett enda jobb sedan han gjorde bokslut förra året. Han är väldigt bra förberedd och tidigare har han alltid gått bra efter vila. Vi får väl hoppas att det blir likadant i år, säger Stefan Melander.</p>



<p class="wp-block-paragraph">Perfekt startspår och spetsläge är Click Baits perfekta förutsättningar. Hur länge är han först?</p>



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



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



<p class="has-drop-cap wp-block-paragraph">2Några lättlösta lopp. Andra som är desto svårare. Så säger Sulkysports tipsexpert om dagens V75-omgång på Mantorptravet.</p>



<p class="wp-block-paragraph">Att sätta ett enkelstreck för Timo Nurmos-tränade <strong>Esposito</strong> (e. Villiam) tvekar inte vår tipsexpert det minsta för:<br><em>”Esposito gjorde en god prestation från bakspår näst senast i bronsdivisionens final. Han skulle börja plocka längder från sjätte utvändigt på slutrundan och det var föga oväntat en omöjlig uppgift även om han fullföljde väl. Senast pep han till tät direkt i Solvalla Hästägarföreningens Vårvintervandringspris, rusade undan i klar ledning och höll marginalen hela vägen. Från ett utsökt utgångsläge, trolig spetshäst i tidigt skede och som perfekt inmatchad i klassen ska han vara favorit i det här loppet.”</em></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-03-09_22_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-03-09_22_5">Sulkysport V75 – 15 andelar á 150 kr/styck</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/2024/02/victorytillyshjtzelitloppet000528-617x333.jpg" alt="" class="wp-image-548336"/><figcaption class="wp-element-caption">StigH Johanssons största seger med sin största stjärna: Victory Tilly vann Elitloppet 2000. Tvåa slutade franske General du Pommeau. Foto Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Idag kommer en av Frankrikes främsta travare under slutet av 1990- och början av 2000-talet – <strong>General du Pommeau</strong> (e. Sebrazac-Actrice du Pommeau) – firas på Haras du Pays d’Auge i Notre-Dame-d&#8217;Estrées-Corbon. Han fyller 30 år den 3 maj, men redan idag blir det födelsedagskalas för ”le Général aux pieds nus”, eller ”barfotageneralen.” </p>



<p class="wp-block-paragraph">General du Pommeau tävlade för framlidne Jules Lepennetier och radade storloppssegrar med triumfen i Prix d’Amérique som kronan på verket. Han vann också i Criterium des Jeunes, Criterium des 4 &#038; 5 ans, Criterium Continental, Prix de Capucine, Prix de Paris, trippla upplagor av Prix René Balliere och Prix d’Ete. I Sverige tog General du Pommeau hem Åby Stora Pris och slutade tvåa i Elitloppet bakom <strong>Victory Tilly</strong> 2000.<br>Sitt rekord 1.10,7ak noterade han just i Elitloppets final och totalt inbringade karriären 3.570.114 euro, vilket gör honom till den femte vinstrikaste travaren i Frankrike efter Bold Eagle, Timoko, Ready Cash och Jag de Bellouet.</p>



<p class="wp-block-paragraph">Som avelshingst satte han inga stora spår när det gällde stora segrar och han blev bara far till en Grupp I-vinnare; <strong>Marquis du Pommeau</strong>, 1.11,2ak/2.968.138 kr, vann Svenskt Travkriterium 2006. <br>General du Pommeaus sista kull föddes 2013 i Frankrike och totalt blev det 204 avkommor. Av dessa tjänade stoet <strong>Talicia Bella</strong> (u. Illcia Bella), 1.10,6/€891.400, allra mest pengar. Sedan dess har han levt pensionärsliv i Notre-Dame-d’Estrées-Corbon i Calvados.</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/2023/07/danielwajerstensulky-617x333.jpg" alt="" class="wp-image-475628"/><figcaption class="wp-element-caption">Daniel Wäjersten. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4I lördags slog vintermeetinget på Vincennes igen för säsongen och 15 segrar blev det för svenskfödda travare, varav sex tränades av svenskar. Igår drog den andra Parisbanan Enghien igång sin vårsäsong och det slutade med seger för en svenskfödd pch svensktränad travare direkt.<br>Daniel Wäjersten-tränade <strong>Chitchat</strong> (e. Maharajah), som tränas av Daniel Wäjersten och ägs av Stall SoFo, slog ill i Prix de Noirmoutier (€52.000) igår och tog hem förstapriset på 23.400 euro.</p>



<p class="wp-block-paragraph">Benjamin Rochard satt i sulkyn bakom Wäjerstens travare, som gav hästen en resa mitt i fältet i andraspår. 1.500 meter från mål i loppet över 2.875 meter klev Rochard på i tredjespår och in i slutsvängen skuggade han ledande favoriten, Alessandro Gocciadoros Jimmy Ferro Br (e. Love You). 200 meter från mål på Enghiens långa upplopp kopplades segergreppet och Chitchat gick undan till enkel seger på 1.14,6/2.875 meter.<br>Triumfen var Daniel Wäjerstens första tränarseger på fransk mark i tolfte försöket.</p>



<p class="wp-block-paragraph">På samma bana blev det också seger för Tomas Malmqvists <strong>Light My Fire</strong> (e. Ready Cash-Reethi Rah Jet) i Prix Cyrano II (€40.000) och Alexis Collette på 1.15,2a/2.150 meter. Det var andra segern i karriären för femfaldige euromiljonären Bold Eagles helbror. </p>



<p class="wp-block-paragraph">Modern <strong>Reethi Rah Jet </strong>(e. Love You), 1.19,0/€7.990, har också lämnat <strong>Cash and Go</strong> (e. Ready Cash), 1.11,3/€347.608, <strong>Eagle Eyes</strong> (e. First de Retz), 1.12,5/€281.400, <strong>Hunter Valley</strong> (e. Charly du Noyer), 1.12,9/€121.740, <strong>French Gold</strong> (e. Jasmin de Flore), 1.13,2/€121.225, och <strong>Anantara Jet</strong> (e. Ganymede), 1.14,7/€102.410.</p>



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



<p class="has-drop-cap wp-block-paragraph">51980-talsstjärnan <strong>Rex Rodney</strong> (e. Doctor Rodney) är den ende norskfödde hästen som vunnit Elitloppet. Det gjorde han tillsammans med sin ständige följeslagare Kjell Håkonsen inför jublande landsmän på Solvalla 1986. Rex Rodney vann 108 av 179 starter och tjänade 5,8 miljoner kronor under sin karriär.</p>



<p class="wp-block-paragraph">Rex Rodneys Äreslopp på hästens hemmabana Forus, där han för övrigt namngivit både restaurangen och sekreteriatet, var på 2000-talet ett riktigt storlopp för fyra- och femåringar och åren 2006–2011 var förstapriset hela 300.000 norska kronor. Den perioden sågs svensktränade vinnare som <strong>Plantagenet, Micro Mesh</strong> och <strong>Select Yankee</strong>. Efter <strong>Amour d’Occagnes</strong> seger 2012 gick loppet i dvala och återuppstod som snabblopp först 2018.</p>



<p class="wp-block-paragraph">I eftermiddag på Forus avgörs årets upplaga av det en gång i tiden så betydande loppet – som ett försök i norska silverdivisionen. En häst som sticker ut är Pål Buers sexåring <strong>Thai M.Square</strong> (e. Broadway Hall), som vunnit 22 av 29 starter i karriären!</p>



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



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



<p class="has-drop-cap wp-block-paragraph">6Kvällens internetauktion hos Travera har samlat 20 nummer i katalogen. Det handlar om 16 hästar och betäckningsrätt för 2024 i hingstarna Brillantissime, Face Time Bourbon, Flocki d’Aurcy och Six Pack.</p>



<p class="wp-block-paragraph">Tio starthästar bjuds ut. Bland dessa finns fyraårige valacken <strong>Lightningflash</strong> (e. S.J.’s Caviar), som efter galopp i debuten och sedan två andraplatser nu ståtar med tre raka segrar och är obesegrad 2024 i Peter Arnqvists regi.<br>En ettåring, en tvååring och tre fölston finns också till försäljning.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se hela ”katalogen” och följa budgivningen under kvällen.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7Ett av Finlands större lopp för kallblod är Karjalainen-Ajo (€25.200) med cirka 135.00 svenska kronor till vinnaren. I eftermiddag i Joensuu är det dags för årets upplaga och i startfältet finns de senaste två årens vinnare <strong>Morison</strong> (e. Erikasson) och <strong>Veeran Poika</strong> (e. Erikasson). Båda har kommit upp i åren, 13 respektive 15 år gamla, och ställs mot ”ungtuppar” som nioårige segermaskinen <strong>Issakan Valo</strong> (e. Camri), som vunnit 31 lopp men inte sprungit fortare ön 1,24,4a, och norskfödde <strong>Havglimt</strong> (e. Moe Odin).</p>



<p class="wp-block-paragraph">Den sistnämnde är en av ganska många norskfödda kallblod – även en del svenska för all del men inte i lika hög klass – som tagit vägen österut till Finland. Havglimt tävlade framgångsrikt för Öystein Tjomsland och vann Svenskt Kallblodsderby 2020. Dessutom slutade han tvåa i både Kriteriet och Derbyt i Norge. I somras såldes hingsten till Antti Ala-Rantala, som både tränar och kör.</p>



<p class="wp-block-paragraph">I samma stall finns den mest framgångsrike norske hästen i Finland de senaste åren, <strong>Nyland</strong> (e. Feseth Lynet), som sprungit in över 320.000 euro och varit med i Elitkampen på Solvalla tre år i rad.<br>Nyland startar i Kaustinen på måndag och ställs bland annat mot en annan av Ala-Rantalas kallblod, svenskfödde <strong>Gott Klirr</strong> (e. Åsajerven), 1.22,5ak/1.425.556 kr, som köptes från Jan-Olov Perssons stall i slutet av förra året för 95.000 kronor på Traveraauktion. Hästen tog i ett montélopp i tisdags första segern på finsk mark i femte försöket.</p>



<p class="wp-block-paragraph"><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5KT18wOS4wMy4yMDI0LnBkZg%3D%3D&#038;m=NJGbx6UW%2BimUFtz%2BBxcBAIS9SME%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till Joensuus tävlingar idag.</a></p>

Fokustema
Morgonsvepet
Läs senare
Barfotahästar utmanar vinterns kung
Elitloppshäst mot vinterkung. Barfotageneralen firas på 30-årsdagen. Wäjerstens första triumf i Frankrike. Silverdivisionshästar hedrar Norges störste. Segerstaplare säljs på auktion. Svenskt kallblod på segerjakt i Finland.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
