<p>Norrbottens Stora Pris (V75-7) har lockat ett häftigt startfält som ska slåss om segerchecken på en miljon kronor. Fyra Elitloppsdeltagare finns bland de tio som gör upp och därtill väljer Alessandro Gocciadoro att starta vecka-vecka med Jämtlands Stora Pris-vinnaren <strong>Vernissage Grif</strong> som gör resan upp med stallkamraten <strong>Zaccaria Bar</strong> och fyraåringstoppen Bepi Bi som startar i ett lopp före V75-spelet tar vid.</p>
<p>Som ofta när det är V75 norröver är flera av loppen lite ojämna med några tydliga toppar och lite svagare bredd, men det har sett mer ojämnt ut motsvarande tävlingsdag tidigare ska sägas så totalt sett ska vi inte klaga.</p>
<p>Några lopp är faktiskt riktigt luriga. Kallblodsdivisionen kan mycket väl resultera i en riktig skräll precis som i lördags och inte heller Diamantstoet ser helt lättlöst ut om man inte väljer att tro att <strong>Balsamine Font</strong> (V75-4) bara är bäst sin ålder till trots.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2021/06/19v75.pdf" target="_blank" rel="noopener">Här kan du ta del av lördagens startlistor till Bodens tävlingar.</a></p>
<h2>Avd 1 – Klass I, 2.140 meter voltstart</h2>
<p>Normalt sett är detta en väldigt passande uppgift för <strong>Gogobet Sisu</strong>, men hur står det egentligen till med hästen för dagen? I lördags galopperade han 300 meter före mål utan att se superstark ut i det skedet och täta starter blir per automatik ett frågetecken. <strong>Leave Your Sox On</strong> verkar vara tillbaka med besked efter ett par plumpar. Han har vunnit från dödens respektive tät och lyckas Mika Forss trycka sig till tät med hästen via springspår ökar segerchansen markant. Att stallkamraten <strong>Amperage Hanover</strong> har det andra springspåret behöver inte vara något minus även om det är olika ägare på hästarna&#8230; <strong>Silver Bullit</strong> och framförallt <strong>Mister Donald</strong> är på väg uppåt, men står liksom favoriten med stängda startspår.</p>
<h2>Avd 2 – Kallblodsdivisionen, 2.140 meter voltstart</h2>
<p>Ett riktigt lurigt kallblodslopp där det är många om budet. All respekt för <strong>G.G.Ojjdo</strong> som skrällvann i lördags och var riktigt bra, men blir han klar favorit här vill vi gärna gardera. Bland annat med <strong>Sundbo Nova</strong> som stärks upp med Björn Goop i sulkyn och som har visat toppform i senaste starterna. Läget alar verkligen till hennes fördel. <strong>Bol Brage</strong> finns i hennes rygg direkt och lyckas Mats E Djuse antingen hålla den eller ta sig ut och sätta sin häst i bra position i andraspår så kan det gå vägen. <strong>Gull Rubin</strong> känns formstarkast och tuffast av tilläggshästarna, men här är det som sagt många om budet och inget känns på något vis givet i det här loppet.</p>
<h2>Avd 3 – Klass II, 2.140 meter autostart</h2>
<p>Björn Goops <strong>Pewdiepie</strong> övertygade vid segern i Lilla Harpers där han tävlade barfota runt om för första gången. Nog för att han fick ett bra lopp bakom ledaren Shejk, men sättet han avgjorde på var riktigt snyggt och det såg inte helt tomt ut över mål. Från spår sju bakom bilen lär han dock inte något gratis denna gång. <strong>Nicois du Gull</strong> har tagit två raka spetssegrar och ser ut som en ny häst efter omlagd träning. Nu är det full väg som gäller och klart tuffare motstånd. Det kittlar verkligen med <strong>Zola Soft</strong> i det här loppet. Hästen har två segrar och en andraplats (förlorade mot Merrimac S.G. trots en toppinsats) på tre starter på svensk mark och det är ett stort plus att Mika Forss ska köra henne i det här loppet. Lägesgynnade <strong>M.T.Oberon</strong> kommer till start med bevisad form och får inte glömmas bort även om meriterna är från enklare sällskap.</p>
<h2>Avd 4 – Diamantstoet, 2.140 meter voltstart</h2>
<p>Det är inte enkelt för ett fyraårigt sto att kliva ut mot äldre hästar och därtill runda dem från 40 meters tillägg, men vi kan inte blunda för att <strong>Balsamine Font</strong> känns klart tuffast i det här sällskapet. Hon är härdad i tuffa lopp på Vincennes, såg lysande ut i comebacken på Solvalla och galopperade lite oturligt i ett skede av Fyraåringseliten för ston där det gick väldigt fort. Här tar man omtag och då hästarna på start- och mellanvolten inte känns alltför tuffa så ska hon ha god segerchans. <strong>Mellby Harissa</strong> mattades markant från tät senast och frågan är hur ett sådant lopp sätter sig psykiskt. Gången innan var hon duktig spurttvåa i Lovely Godivas Minne. <strong>Ava</strong> var moralisk vinnare av Diamantstofinalen senast, men står sämre inne i det här loppet. <strong>Lovely O.O.</strong> tar revansch efter galoppmisslyckandet förra veckan och känns bäst på mellanvolten medan <strong>Kaitlin Way Scott</strong> möjligen skulle kunna rinna undan från tät om hon får hållas en längre bit.</p>
<h2>Avd 5 – Bronsdivisionen, 1.640 meter autostart</h2>
<p><strong>Swagger</strong> jagar revansch för den snöpliga galoppen på Umåker i maj där han hade det bronsförsöket i sin hand när felstegen kom mitt på upploppet. Han har gjort ett lopp efter det och lämnat helt rätt formintryck så vi måste tro att han har toppchans att bomba hem det här loppet. Räkna med att Björn Goop försöker ordentligt med <strong>Astronacente Zac</strong> på utsidan som var tvåa bakom Rotate i Klass I-finalen. Att han ska komma förbi av egen kraft har vi dock svårt att se, men vi blir däremot inte överraskade om han tar en lugn dödens då hästen känns allra vassast när han får gå i fritt läge. <strong>Syoss</strong> har en hög högstanivå och gjorde det på intet vis dåligt på Umåker i deras bronslopp även om han bara fick med sig en femteplats den dagen. Loppets bredd känns begränsad och spontant är det denna trio som gör upp.</p>
<h2>Avd 6 – Silverdivisionen, 2.640 meter autostart</h2>
<p><strong>Upstate Face</strong> såg grymt bra ut i lördags och vi finner ingen anledning att tro att den ett varv längre distansen ska vara någon egentlig nackdel för honom. Däremot så är utgångsläget uselt och bland motståndarna finner vi fyra konkurrenter som vi åtminstone kan se ge honom en match även om loppet i stort är väldigt ojämn. <strong>Cab Lane</strong> var favorit i silverfinalen och höll bra från tät. Han förlorade helt enkelt mot bättre hästar, men kan absolut vinna ett sådant här lopp om inte tempot blir för högt. <strong>Balotelli Crown</strong> sköt till jättebra som tvåa i silverfinalen och har rena drömläget åter igen för att få en fin, invändig smygare. <strong>Ivory di Quattro</strong> gjorde ett bra lopp lite i skymundan i Harper Hanovers och går inte räkna bort trots spår sju. <strong>Algot Zonett</strong> är ute över den distans som passar honom bäst när han möter lite mer kvalificerat motstånd och ska också räknas tidigt.</p>
<h2>Avd 7 – Norrbottens Stora Pris, 2.140 meter autostart</h2>
<p>En mycket stark upplaga av Norrbottens Stora Pris. <strong>Vernissage Grif</strong> var jättebra i lördags när han vann Jämtlands Stora Pris, men samtidigt blev det ganska rätt då han kunde flyttas fram till dödens i ett skede då det inte kostade så mycket samtidigt som några av konkurrenterna underpresterade. Vi har stor respekt för hästen, men komma gardera honom när det är täta starter och svårt startspår. <strong>Moni Viking</strong> hann helt enkelt inte med i Elitloppet även om han var femma på 1.09,4. Det var inget fel på insatserna i varken försök- eller final och det är ingen hemlighet att denna distans passar honom bättre. För oss är det han eller <strong>Very Kronos</strong> som är förstahästen i loppet. Den sistnämnde kommer vilja ha ett ord med i laget och har för ovanlighetens skull begåvats med ett bra utgångsläge från vilket han kan ta ledningen. Elitloppstrean <strong>Gareth Boko</strong> är också tidig liksom <strong>Who&#8217;s Who</strong> och givetvis även <strong>Wild Love</strong> som bara lyfter och lyfter oavsett vilka utmaningar hon ställs inför.</p>
