
<p class="has-drop-cap wp-block-paragraph">1Sedan 1996 har kallbloden kunglig glans över ett lopp. Då kördes loppet med det fullständiga namnet ”H.K.H Prinsessan Madeleines Pokal – för bevarandet av den svenska kallblodsrasen” för första gången. Det handlar om ett fyraåringslopp över sprinterdistans med startbil mitt i sommaren.</p>



<p class="wp-block-paragraph">Och visst har de förutsättningarna borgat för flera fartfester och även två gällande världsrekord. Hingsten och fortsatt obesegrade <strong>Brenne Borken</strong> (e. Bork Odin) travade fantastiska 1.20,2a vid segern tillsammans med Öystein Tjomsland förra året och stoet <strong>Lannem Silje </strong>(e. Åsajerven) noterade 1.21,0a vid sin triumf med Tor Wollebaek.</p>



<p class="wp-block-paragraph">Båda dessa är norskfödda och snabbaste svenska vinnartiden delas mellan två hästar från Jan-Olov Perssons stall: både <strong>Järvsö Pegasus</strong> (e. Tangen Scott) 2017 och <strong>B.W.Prinsen</strong> (e. B.W.Modde) 2019 travade 1.22,3a/1.640 meter, en tid som står sig som svenskt rekord.</p>



<p class="wp-block-paragraph">Ikväll är det dags för årets upplaga i Bollnäs och kanske blir det för första gången finska fanan i topp?! Öystein Tjomslands bidrag är nämligen finskfödde och finskdelägde <strong>Weikko</strong> (e. Välähdys), som vann alla sina tre starter i Finland som treåring med förkrossande marginal. I tävlingsdebuten i höstas slaktade det finska rekordet för treåringar med tre sekunder när han vann på 1.26,2a/2.100 meter i Mikkeli.</p>



<p class="wp-block-paragraph">Nu väntar en högintressant årsdebut för hästen som bland annat vässats mot stallets snabbloppshästar på Tjomslands gård utanför Sörlandet inför comebacken.</p>



<p class="wp-block-paragraph">Tio svenskfödda fyraåringar och en norsk står för motståndet i onsdagens lopp, där Weikko inleder från spår sju bakom bilen. </p>



<p class="wp-block-paragraph">Att vinna Prinsessan Madeleines Pokal är annars ett bra tecken för vad som komma skall i Östersund i augusti i Kallblodsderbyt.</p>



<p class="wp-block-paragraph"><strong><em>Hästarna som tagit dubbeln Princessan Madeleines Pokal och Svenskt Kallblodsderby:</em></strong></p>



<ul class="wp-block-list">
<li>1997 <strong>Röder</strong> (e. Alm Svarten)</li>



<li>2000 <strong>Sjefen</strong> (e. Elding)</li>



<li>2003 <strong>Troll Kevin</strong> (e. Troll Jahn)</li>



<li>2005 <strong>H.G.Balder</strong> (e. Lome Elden)</li>



<li>2008 <strong>Järvsöviking</strong> (e. Järvsöfaks)</li>



<li>2012 <strong>Tekno Odin</strong> (e. Moe Odin)</li>



<li>2013 <strong>Hellin Faxen</strong> (e. Järvsöfaks)</li>



<li>2014 <strong>Lannem Silje</strong> (e. Åsajerven)</li>



<li>2017 <strong>Järvsö Pegasus</strong> (e. Tangen Scott)</li>



<li>2021 <strong>Tangen Bork</strong> (e. Bork Odin)</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">2Bollnäs (start 18.15) har en fin försommarkväll med fler godbitar på programmet vid sidan om Prinsessan Madeleines Pokal. Bland annat dyker en drottning upp. Jan-Olov Persson-tränade <strong>Majblomster</strong> (e. Tekno Odin) sopade rent i storloppen för ston som treåring med dubbla titlar i Kriteriestoet plus vinst i Oaks i Norge. I Stokriteriet på Bjerke travade hon världsrekordsnabbt – 1.23,6a/2.100 meter – på Bjerke.</p>



<p class="wp-block-paragraph">I vår har hon värmt upp med två enkla segrar innan marschen mot sommarens och höstens klassiska lopp fortsätter ikväll i stoloppet Hambostinan, där hon även möter femåriga ston som belastas med 20 meters extra tillägg. Där finns bland andra Merete Viksås tvåa från norska Stoderbyt ifjol,<strong> Åse Mona</strong> (e. Bork Odin).</p>



<p class="wp-block-paragraph">På varmblodssidan väntar 100.000 kronor på vinnaren i Norrländskt Varmblodsmästerskap för treåringar, som lockat flera spännande hästar. Reijo Liljendahl mönstrar amerikanska duon <strong>Lavender</strong> (e. Walner) och <strong>Ronno</strong> (e. Walner), som ställs mot Alessandro Gocciadoros <strong>Falcon Dany Bar</strong> (e. Vitruvio) och Paul Hagoorts <strong>Fly Equos Jet</strong> (e. Readly Express).<br>– Falcon Dany Bar har gjort allting rätt sedan han kom till Skandinavien. Han blir bara bättre och bättre hela tiden ju mer rutin han samlar på sig och jag måste vara optimistisk igen från ett bra startspår med en häst som visat att han kan öppna bra, säger Alessandro Gocciadoro.</p>



<p class="wp-block-paragraph">De mest meriterade äldre kallbloden möts i flerklassloppet Andungens Minne, där två av de tilltänka Elitkampshästarna dyker upp. Fjolårets komet <strong>Bäcklös Uriel </strong>(e. Smedheim Solan) har inte fått till det i årets två starter, medan <strong>Tekno Jerven</strong> (e. Tekno Odin) är i full gång med sin tjänstgöring som avelshingst hos Fredrik Fransson. 40 meter före dessa startar bland annat vinnaren av dubbelcupens final i april, <strong>Brageson</strong> (e. Lome Brage).</p>



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



<p class="has-drop-cap wp-block-paragraph">3Medan Solvalla återhämtar sig efter Elitloppshelgen delas kvällens expresstrav med V86 mellan Bollnäs och Åby (första start 18.27).</p>



<p class="wp-block-paragraph">Klassiske vinanren Dancer Broddes lillasyster <strong>Daim Brodda</strong> (e. Readly Express) tränas i Norge av Thor Borg hoch hans team och det fyraåriga stoet tog tid på sig innan hon debuterade. Detta skeede först i november förra året, men det har börjat bra. Fyra raka segrar följdes av tredjeplatsen i senaste starten, men det är inget att be om ursäkt för. Daim Brodda fick sitt elddop i ett Breeders Crown-försök.</p>



<p class="wp-block-paragraph">Nu står hon bra inne i ett fyraåringslopp för ston och Eirik Höitomt kan borga för att stoet återupptar segerraden.</p>



<p class="wp-block-paragraph">Och på tal om segerrader. Efter galopp i debuten som tvååring har Per Nordström-tränade <strong>Bootsman</strong> (e. Campo Bahia) plockat fyra raka segrar, två förra året och ytterligare två i vår. Ikväll fortsätter jakten på ett staket i programraden när han kommer ut i ett treåringslopp utanför V86-kupongen.</p>



<p class="wp-block-paragraph">––> Sulkysports spelstuga med viktiga punkter, spikar, drag och favoriter i fara publiceras som vanligt klockan 12.00 idag.</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/251721_V86_2024-05-29_40_1" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



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



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



<p class="has-drop-cap wp-block-paragraph">4En svensktränad häst kommer till start i eftermiddagens lopp i Caen (första start kl. 11.40).</p>



<p class="wp-block-paragraph">Det handlar om Anna Karlssons <strong>Kapoceo</strong> (e. Coup de Poker) som ska försöka återfinna vinnarspåret efter att tagit två raka segrar i början av året, men därefter blivit diskvalificerad två gånger i följd.</p>



<p class="wp-block-paragraph">Det är Yoann Lebourgeois som rattar Karlssons fyraåring som kommer till start i Prix de Blonville (€21.000) där det tävlas om 9.450 euro i segerpremie.</p>



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



<p class="has-drop-cap wp-block-paragraph">5De finska treåringarna lös med sin frånvaro i årets Breeders Course-lopp på Solvalla, men ikväll gör de upp på den inhemska huvudstadsbanan Vermo.</p>



<p class="wp-block-paragraph">Där avgörs Treåringspokalen (€22.000) med 10.000 euro i segerpremie och bland de elva deltagarna syns svenskfödda <strong>Arctic Estelle</strong> (e. Express Duo) som inlett karriären med sex segrar på nio starter. Det är Pekka Korpi som tränar det av Markku Nieminen-tränade stoet och Korpi har även <strong>Arctic Emerald </strong>(e. Express Duo) till start i samma lopp.</p>



<p class="wp-block-paragraph"><strong>Startlista Treåringspokalen</strong><br><em>2.120 meter autostart</em></p>



<ol class="wp-block-list">
<li>Brandon Orden (e. Brad de Veluwe) – Riku Salminen</li>



<li>Enrico Combo (e. Maharajah) – Iikka Korpi</li>



<li>Return of Wurst (e. Spider Blessed) – Jukka Torvinen</li>



<li>Wik&#8217;s Noe Nee Pee (e. Enjoy Lavec) – Jarmo Saarela</li>



<li>Lil Runner (e. So Perfect) – Antti Teivainen</li>



<li>Gallinago Snipes (e. Muscle Mass) – Markku Nieminen</li>



<li>Arctic Emerald (e. Express Duo) – Ari Moilanen</li>



<li>Stonecapes Xantee (e. Brillantissime) – Tapio Perttunen</li>



<li>Top Hit (e. Toast Of Lindy) – Ville Koivisto</li>



<li>Arctic Estelle (e. Express Duo) – Santtu Raitala</li>



<li>BWT Jackpot (e. Maharajah) – Hannu Torvinen</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">6Onsdags- och lördagsföljetongen <strong>Benchmark</strong> (e. Nuncio) 1.12,1ak/529.900 kr är ny på Björn Goops träningslista.</p>



<p class="wp-block-paragraph">Den femårige valacken som tävlat flitigt inom såväl Solvallaserien som inom STL (en andra- och en tredjeplats som bäst på sex försök) har nu lämnat Stefan Melanders stall efter försäljning och finns numera hos Färjestadtränaren Goop.</p>



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



<p class="has-drop-cap wp-block-paragraph">7Snabblopp för såväl kall- som varmblod stod i centrum vid tisdagskvällens tävlingar på Bjerke.</p>



<p class="wp-block-paragraph">Öystein Tjomsland-tränade<strong> Grisle Odin G.L.</strong> (e. Moe Odin) vann den kalla upplagan på 1.23,8a/2.100 meter i lag med Åsbjörn Tengsareid och i varmblodens motsvarighet stod Z.Boko (e. Zola Boko) i en klass för sig.</p>



<p class="wp-block-paragraph">Den sistnämnde gav inte dödenstravande Beads (e. Archangel) skuggan av en chans utan försvann ifrån till överlägsen vinst från tät på 1.12,9a/2.100 meter.<br>Beads mattades så till den grad att han kom i mål som fyra och däremellan tog Charleston Volo (e. Classic Photo) och Dream Builder (e. Joke Face) pallplaceringarna.</p>

Fokustema
Morgonsvepet
Läs senare
Finska fanan i topp?
Om kvällens kalla topplopp i Bollnäs, svensk segerjakt i franska Caen och om en onsdags- och lördagshäst som bytt regi går bland annat att läsa i veckans tredje morgonsvep.
