
<p class="has-drop-cap wp-block-paragraph">1Från femåringsloppet Prins Carl Philips Jubileumspokal på Färjestad på långfredagen till Elitloppet på Solvalla – den resan talas det en hel del om, men bara en häst har lyckats vinna båda loppen samma år under det förstnämnda loppets 28-åriga historia.</p>



<p class="wp-block-paragraph">Stefan Hultman-tränade<strong> From Above</strong> (e. Zoot Suit) gick in i femåringssäsongen med segrar i Kriteriet, Derbyt och Breeders Crown i bagaget och inledde på bästa sätt med segern i Prins Carl Philips Jubileumspokal i mitten av april. Efter en genomkörare på Solvalla ett par veckor senare ställdes siktet in mot världseliten i Elitloppet. Där slutade From Above tvåa i försöket, men när det verkligen gällde i finalen spurtade han tillsammans med Örjan Kihlström ned tätduon Victory Tilly och Scarlet Knight och plockade hem ännu en tung titel.</p>



<p class="wp-block-paragraph">Ytterligare två vinnare av Prins Carl Philips Jubileumspokal har som äldre segrat i Elitloppet. <strong>Gidde Palema</strong> (e. Alf Palema) vann i Björn Goops regi på Färjestad 2000 och plockade hem Elitloppet för Åke Svanstedt fyra år senare. Roger Walmann sade pass till Elitloppet med <strong>Magic Tonight </strong>(e. Andover Hall) som femåring 2014 och fick istället jubla på Solvalla året efter.</p>



<p class="wp-block-paragraph">Ifjol fick prispengarna ett skjuts uppåt och förstapriset var rekordhöga 300.000 kronor, precis som i år. Det har lockat blott sju hästar, men kvaliteten är det absolut inget fel på. Fyra av hästarna har Grupp I-seger på meritlistan från unghästsäsongerna!</p>



<p class="wp-block-paragraph">Det handlar om Breederrs Crown-vinnaren A Fair Day (e. Maharajah), Gran Premio Unione Europeo-ettan <strong>Diamond Truppo </strong>(e. Varenne), Kungapokalssegraren <strong>Dancer Brodde</strong> (e. Bold Eagle) samt <strong>Following</strong> (e. Nuncio), som vann korta E3.</p>



<p class="wp-block-paragraph"><strong>Så här har det gått för de 13 senaste vinnarna av Prins Carl Philips Jubileumspokal i Elitloppet samma år:</strong></p>



<p class="wp-block-paragraph"><em>År – Segertid – Vinnare (far) – Elitloppet samma år</em></p>



<ul class="wp-block-list">
<li>2011 – 1.10,7a:<strong> Prince Tagg </strong>(e. Prince R.S.) – oplacerad i försök</li>



<li>2012 – 1.11,5a: <strong>Hard Cider</strong> (e. Yankee Glide) – ej med</li>



<li>2013 – 1.12,6a: <strong>Panne de Moteur</strong> (Credit Winner) – oplacerad i försök</li>



<li>2014 – 1.09,5a: <strong>Magic Tonight </strong>(e. Andover Hall) – ej med</li>



<li>2015 – 1.10,1a: <strong>Dream With Me</strong> (e. Dream Vacation) – ej med</li>



<li>2016* – 1.11,2a:<strong> Je T&#8217;Aime Express </strong>(e. Symphonic Hanover) – ej med</li>



<li>2017 – 1.11,4a: <strong>Poet Proline</strong> (e. Quite Easy) – ej med</li>



<li>2018 – 1.10,7a: <strong>Pastore Bob</strong> (e. From Above) – trea i försök och sjua i finalen</li>



<li>2019 – 1.10,1a: <strong>Perfect Spirit</strong> (e. Andover Hall) – ej med</li>



<li>2020 – 1.10,5a: <strong>Missle Hill </strong>(e. Muscle Hill) – tvåa i försök och femma i finalen</li>



<li>2021 – 1.09,8a: <strong>Click Bait </strong>(e. Cantab Hall) – oplacerad i försök</li>



<li>2022 – 1.09,4a: <strong>San Moteur </strong>(e. Panne de Moteur) – ej med</li>



<li>2023 – 1.09,5a: <strong>Jimmy Ferro B.R.</strong> (e. Love You) – ej med</li>
</ul>



<p class="wp-block-paragraph">*2016 var Propulsion först i mål men fråntogs segern i efterhand. Han slutade fyra i Elitloppsfinalen samma år.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Medan hingstar och valacker gör upp i Prins Carl Philips Jubileumspokal möts de femåriga stona i en stark upplaga av Folke Hjalmarssons Minneslopp. Medan fem av deltagarna gör årsdebut och en sjätte inte startat sedan mitten av januari, så har Stefan Melander-tränade<strong> Decision Maker </strong>(e. Nuncio) inte haft någon längre paus sedan mars förra året.</p>



<p class="wp-block-paragraph">Hon fick inte till det i de klassiska loppen som fyraåring (diskvalificerad i Breeders Crown i enda finalen), men kunde summera en stark säsong innehållande sju segrar och 1,6 miljoner insprunget sedan hon avslutat året med seger möt de äldre stona i finalen av stoeliten annandag jul.</p>



<p class="wp-block-paragraph">Dagens motståndare då? <strong>Queen Belina </strong>(e. Nuncio) tog sin andra seger i Breeders Crown-final och<strong> Cabaret Artist </strong>(e. Propulsion) vann norska Derbytstoet. Detta spetsat med Alessandro Gocciadoros<strong> Delicious Gar </strong>(e. Father Patrick) och kampen om 150.000 kronor i förstapris blir spännande.</p>



<p class="wp-block-paragraph">Loppet hedrar Folke Halmarsson som blev tredje kusk i tusenklubben i Sverige när han tog klivet in 1957. Det hade bara Gösta Nordin och Algot Scott lyckats med före Folke. Under tre decennier var han tränare på Färjestad och plockade hem hela 18 banchampionat. 1942 blev han dessutom allsvensk kuskchampion. Hans stora stjärna var kallblodet Helge Solo, som vann 116 lopp på 260 starter.</p>



<p class="wp-block-paragraph"><strong><a href="https://sulkysport.se/spelstugan/v75-tips-farjestad-29-mars/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports spelstuga inför V75 med viktiga punkter, favoriter i fara och spelförslag till Färjestad.</a></strong></p>



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



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-03-29_15_5" class="">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-29_15_5" class="">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3En högintressant årsdebutant dyker upp på Eskilstuna (första start 12.20) inleder långfredagens travsport på svensk mark. Reijo Liljendahls italienske Grupp I-vinnare<strong> Epsom As </strong>(e. Muscle Mass) slog till i Breeders Course-finalen på Elitloppsdagen, där en miljon kronor plockades hem från ledningen tillsammans med Ulf Ohlsson.</p>



<p class="wp-block-paragraph">Detta följdes upp med tredjeplatsen i långa E3-finalen och fjärdeplatsen i korta upplagan, innan punkt för säsongen sattes efter en start i början av september.<br>– <em>Det är en bra häst, men han fick problem med fräschören och motivationen i slutet av sommaren. Han fick tuffa lopp i Breeders Course och E3, och jag ville ta tillbaka hästen och göra honom i ordning för fyraåringssäsongen</em>, sade Reijo Liljendahl till ATG Live om det tidiga bokslutet.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/epsomasuodef-617x333.jpg" alt="" class="wp-image-457232"/><figcaption class="wp-element-caption">Reijo Liljendahl-tränade Epsom As vann Breeders Course First Final ifjol. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Nu är valacken redo igen efter en rejäl träningsvinter hos Liljendahl.<br>– <em>Han har fått mycket tid och mycket träning. Som snabbast har han gått 1.17,5 full väg på Solvalla. Det är en okomplicerad häst som är snabb från början och snabb till slut. Det ä ingen toppform än, han har varit borta länge och går med träningsbalans</em>, sade Reijo.</p>



<p class="wp-block-paragraph">Fyra hästen sluter upp för att möta Reijos topphäst i Påskbomben för fyraåringar med 60.000 kronor till vinnaren.</p>



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



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



<p class="has-drop-cap wp-block-paragraph">4Ron Kuiper har starthäst i dagens högst doterade lopp på Vincennes (första start kl. 16.38).</p>



<p class="wp-block-paragraph">Det handlar om Gatsby Perrine-sonen <strong>Lutteur des Glenan</strong> som kommer till start i Prix Penthesilea (€70.000) för treåringar som tjänat upp till 70.000 euro.<br>Vinnaren belönas med 31.500 euro och det är Anthony Barrier som kör Kuipers springare som alltjämt är segerlös nio starter in i karriären.</p>



<p class="wp-block-paragraph">Svenskintresse finns även i Prix Eos (€53.000) för sexåringar där Jarmo Niskanen startar <strong>Giant Design</strong> (e. S.J.&#8217;s Caviar) och så tävlar Victoriane Marie Goetz <strong>Lucky Guy Boko </strong>(e. Broadway Hall) i samma lopp.</p>



<p class="wp-block-paragraph">Det fjärde och sista svenskhoppet för kvällen är Yannick Henry-tränade Gardner Shaw (e. Ready Cash) som kommer till start i Prix Amalthea (€68.000).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-03-29/" target="_blank" rel="noreferrer noopener">Här kan du ta del av kvällens 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">5En Breeders Crown och Breeders Course-vinnaren mot tvåan och trea i fjolårets upplaga av Deutsches Traber-Derby.</p>



<p class="wp-block-paragraph">Ja, det &#8221;mötet&#8221; kan Victoria Park-banan i Wolvega locka med under förmiddagen, men det handlar inte om något vanligt lopp utan ett rent kvallopp.</p>



<p class="wp-block-paragraph">Paul Hagoort bidrar med <strong>Ester degli Dei </strong>(e. Maharajah) som var hästen som vann just Breeders Crown och Breeders Course i Sverige ifjol, men har även<strong> Y.Not Diamant </strong>(e. Odessa Santana) som slutade tvåa i fjolårets tyska derbyfinal.<br>Trea i samma lopp var Dion Tesselaars <strong>Gio Cash</strong> (e. Victor Gio) som även var tvåa i fjolårets Fyraåringseliten under Elitloppsdagen bakom Double Deciever.</p>



<p class="wp-block-paragraph">Det är den trion som travar ut på den holländska banan klockan 10.50 i vad som har alla förutsättningar för att bli ett sevärt kval.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Mer Holland och Paul Hagoort. I lördags gjorde fjolårets Paralympiatravstvåa tillika Oslo Grand Prix-vinnare <strong>Hades de Vandel</strong> (e. Ganymede) lyckad årsdebut då han vann på 1.12,5a/2.100 meter i Wolvega.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/05/bakkerrobinhagoortpaul220507adamstromstalltz-617x455.jpg" alt="" class="wp-image-298923"/><figcaption class="wp-element-caption">Robin Bakker och Paul Hagoort är duon bakom Hades de Vandel som nu åter siktas mot start på svensk mark. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Nu meddelar Hagoort via ett sms till Sulkysport att siktet ställs in mot storloppsstart i Sverige.<br>&#8221;<em>Hans första stora mål för året är att starta i Paralympiatravet. Före det så ska han ett lopp till i kroppen, men det är inte bestämt ännu om det blir på Wolvega eller om han ska starta i Frankrike</em>&#8221;, informerar Paul Hagoort.</p>



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



<p class="has-drop-cap wp-block-paragraph">7Maria Törnqvist har haft en mycket stark inledning på året med 19 tränarsegrar på 51 starter och drygt 1,3 miljoner kronor i inkörda prispengar.</p>



<p class="wp-block-paragraph">I dagarna klev en Grupp I-finalist in genom stalldörrarna då 2022 års finalist i Svensk Uppfödningslöpning – <strong>Monaco</strong> (e. Djali Boko) 1.14,3ak/210.500 kr – placerats hennes vård efter att tidigare tränats av Conrad Lugauer.</p>



<p class="wp-block-paragraph">Fjolårets treåringssäsong innehöll blott två starter varav den senaste gjordes på Solvalla den 5 juli och totalt har Monaco en seger på nio starter.</p>

Fokustema
Morgonsvepet
Läs senare
En väg mot Elitloppet
Om dagens topptävlingar på Färjestad, Breeders Course-finalvinnarens årsdebut på Sundbyholmstravet och ett högoktanigt förmiddagskval i holländska Wolvega går bland annat att läsa i långfredagens morgonsvep.
