
<p class="has-drop-cap wp-block-paragraph">1 Gösta Bergengren var med och bildade Svenska Travsportens Centralförbund på 1920-talet och var initiativtagare till att Bergsåker byggdes och hade premiär 1932 som Sveriges tredje permanenta bana.</p>



<p class="wp-block-paragraph">Sedan 1965 har han hedrats med ett eget snabblopp och segerlistan bjuder på många fina, gamla märken som Scott Protector, Grande Frances, Piper Cub, Zoogin, Dream Of Goal, Triton Sund, Super Light och många fler.</p>



<p class="wp-block-paragraph">Ikväll är det dags för årets upplaga av det anrika loppet och kanske sällar sig Reijo Liljendahls stjärna <strong>Admiral As </strong>(e. Ready Cash) till det fina sällskapet? Solvallatränaren är nöjd med träningsvintern för fjolårets Elitloppsdeltagare, som travat 1.17,5 som snabbast i jobb på Solvalla inför årsdebuten.</p>



<p class="wp-block-paragraph">Det bjuds fler godbitar på Bergsåker. Som Jörgen Westholm-tränade <strong>Guli Fantom</strong> (e. Bork Odin) som startar i dubbelcupförsöket med sex raka segrar i bagaget, Lannem Siljes treåriga dotter <strong>Lannem Selma</strong> (e. Tekno Odin) på revanschjakt efter galopp i tävlingsdebuten, och delade världsrekordhållaren från förra året, <strong>Drake Kronos</strong> (e. Muscle Hill), i ett litet men spännande försök i fyraåringsserien Norrlands Grand Prix.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/03/29v86.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av kvällens startlistor till tävlingarna på Bergsåker och Solvalla.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2 Över 6,7 miljoner kronor extra ligger i åttarättspotten på V86 i omgången som Bergsåker (första start 18.27) delar med Solvalla (första start 18.15).</p>



<p class="wp-block-paragraph">På huvudstadsbanan ligger stora pengar i potten när det för andra tävlingsdagen i rad är finaldags. I lördags handlade det ju om STL-finaler, medan kvällens höjdpunkter är de tre finalerna i Solvallaseriens andra meeting. 150.000 kronor väntar vinnarna i vardera final.</p>



<p class="wp-block-paragraph"><em>Här är försöksvinnarna i Solvallaseriens meeting två som startar i finalerna:</em></p>



<ul class="wp-block-list">
<li><strong>Högst 150.000 kr: </strong>Needle’em, Catch Me, Even Younger, Buzzed Driving (Mellby Imperial startar ej)</li>



<li><strong>Högst 350.000 kr: </strong>Denco’s Galliano, Joyeux du Cygne, Michigan Bro, Balotelli Face (Vincent C.D. startar ej)</li>



<li><strong>Högst 650.000 kr: </strong>Corazon de B, Dallas, Kron Vici Star (So Far Away Ås och E.L.Jetpack startar ej)</li>
</ul>



<p class="wp-block-paragraph">Sexsiffrig prischeck är det även i flerklassloppet Spelarnas Pokal där vinnaren därtill erhåller en direktplats till Harper Hanovers lopp. Här gör <strong>Golden Guard </strong>(e. Brad de Veluwe) andra starten i Sofia Aronssons regi efter att inlett året med seger på Färjestad för tre veckor sedan.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/drommer-om-storloppen/" target="_blank" rel="noreferrer noopener">Läs vad Sofia säger om hästen här!</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3 De allra mest kända namnen saknas när den andra etappen av Grand National du Trot (€90.000) avgörs på Marseille Borely (första start 13.50) i södra Frankrike denna eftermiddag.<br>Som vanligt står 40.500 euro på spel till vinnaren och det kan mycket väl visa sig bli en strid mellan den av Jean Michel Baudoin-tränade duon<strong> Gaspar d&#8217;Angis</strong> (e. Quaro) och <strong>Epsom d&#8217;Herfraie</strong> (e. Rieussec).</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2021/12/prixbarleduc1-scaled.jpg" alt="" class="wp-image-255474"/><figcaption class="wp-element-caption">Invändge Epsom d&#8217;Herfraie vid seger före 
 Milliondollarrhyme i Prix Bar Le Duc år 2021. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Det blågula intresset i Marseille dyker upp i montéloppet Prix des Caves de Saint-Marc de Caromb (€30.000).<br>David Cinier låter <strong>Spartak Face </strong>(e. Viking Kronos) göra debut under sadel och det sker med Lolita Balayn som ryttare.</p>



<p class="wp-block-paragraph">Det travas även i Reims (första 16.27) och där är svenskhoppen två till antalet. <strong>Myllkärrs Medusa</strong> (e. The Bank) exporterades för sex veckor sedan till Frankrike och gör nu sin första start hos sin nya tränare Alexandre Wissocq i sadelloppet Prix des Joueurs du Stade de Reims (€21.000) tillsammans med Aurélie Gervais.<br>Därtill startar Ron Kuiper <strong>Julius Caesar</strong> (e. Goetmals Wood) i Prix de la Maison de Quartier Chatillons (€18.000) vilken körs av Damien Bonne.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/marseille-borely-2023-03-29/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Marseille.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 Idag gör svenskfödde <strong>Global Withdrawl</strong> (e. S.J.&#8217;s Caviar) årsdebut på finsk mark. Hästen som tränas av Matias Salo hade ett starkt fjolår med åtta segrar på 13 starter och 112.506 euro i intjänade prispengar.<br>Redan för två veckor sedan blev <a href="https://sulkysport.se/ny-inbjudan-till-finlandia-ajo/" target="_blank" rel="noreferrer noopener">hästen inbjuden till Finlandia Ajo</a> som avgörs på Vermo den 7 maj med ett förstapris på 110.000 euro och det är på samma bana som dagens årsdebut äger rum.</p>



<p class="wp-block-paragraph"><strong>Startlista</strong><br><em>2.120 meter autostart, förstapris: 5.000 euro</em></p>



<ol class="wp-block-list">
<li>J.H.Mannerheim – Olli Koivunen</li>



<li>American Hero – Pekka Korpi</li>



<li>Hazelhen Hermes – Tino Paldan</li>



<li>Bag&#8217;s Simoni – Henna Halme</li>



<li>Global Withdrawl – Santtu Raitala</li>



<li>Sahara Sandstorm – Ville Tonttila</li>



<li>Lexus Dream – Jukka Torvinen</li>



<li>Furies Rain – Henry M Bollström</li>



<li>Payet – Juha Utala</li>



<li>M.S.Triple J. – Ari Moilanen</li>



<li>Jason&#8217;s Camden – Hannu Torvinen</li>



<li>Always Ready – Tommi Kylliäinen</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">5 När våren är kommen brukar Alessandro Gocciadoro börja starta hästar på svensk mark och så blir också fallet i nästa vecka.<br>Italienaren tar nämligen sikte mot Färjestads två mest penningstinna lopp under långfredagen.</p>



<p class="wp-block-paragraph">Till Prins Carl Philips Jubileumspokal anmäler Gocciadoro <strong>Jimmy Ferro Br</strong> (e. Love You) 1.12,0/€101.787 som vunnit tre av fyra starter i hans regi varav den senaste togs i Grupp III-loppet Gran Premio Padovanelle (€35.200) i Padova den 12 mars på 1.12,5a/1.640 meter.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/09/clarissa-617x410.jpg" alt="" class="wp-image-214614"/><figcaption class="wp-element-caption">Clarissa och Alessandro Gocciadoro.</figcaption></figure>



<p class="wp-block-paragraph">Därtill får <strong>Clarissa</strong> (e. Exploit Caf) 1.11,5/€252.745 slå följe för att starta i Folke Hjalmarssons Minneslopp för femåriga ston.<br>Hon galopperade bort sig i Fyraåringseliten för ston på Solvalla under fjolåret, men räknade hem tre Grupp II-lopp under hösten och var därtill trea i Prix Oscar Collard (€80.000) på Vincennes i december bakom Bilo Jepson och Toto Barosso.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Sofia Aronsson hade en trivsam måndag med comebackseger för stjärnan <strong>Unico Broline</strong> (e. Cantab Hall) på Färjestad samtidigt som <strong>Mr Mah Can </strong>(e. Maharajah) spurtade in som trea i sitt första framträdande för Axevallatränaren.</p>



<p class="wp-block-paragraph">På hennes träningslista går det att därtill att skönja ett noterbart nyförvärv. Den treåriga, okvalade Maharajah-dottern <strong>Staro Raili </strong>köptes av Hjelte Restaurang AB i Karlstad för 620.000 kronor på Travera-auktionen den 25 februari och är nu satt i träning hos Aronsson.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Det är inte bara nivåhöjning vad det gäller prispengar som gäller denna kväll utan även V86-spelet får sig ett lyft.<br>Inget system hade markerat samtliga åtta vinnare föregående onsdag varpå det är jackpot som stundar denna kväll.<br>Prognosen säger att det ska finnas 15 miljoner kronor i åttarättspotten vilket givetvis förhöjer spelintresset flera snäpp.</p>



<p class="wp-block-paragraph"><em>Vill du spela V86 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/206233_V86_2023-03-29_40_1" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V86 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://www.atg.se/andelskungen/spel/206235_V86_2023-03-29_40_1" target="_blank">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>

Fokustema
Morgonsvepet
Läs senare
Admiral hedrar Bergengren?
Om kvällens penningstinna finaler av Solvallaserien, Alessandro Gocciadoros planerade påskbesök i Sverige samt om dagens Grupp III-lopp i Frankrike går bland annat att läsa i dagens morgonsvep.
